@cyrilmarin/dsh-lemonade 0.2.1

package/README.fr.md

@@ -0,0 +1,186 @@
+# dsh-lemonade-provider
+
+Plugin **dsh** qui intègre [Lemonade Server](https://lemonade-server.ai) comme
+fournisseur de modèles du DeepSeek Harness.
+
+Lemonade expose une API compatible OpenAI (Chat Completions). Ce plugin branche
+cette API sur le service `ctx.llm` du Harness sous la route provider
+**`lemonade`** :
+
+- **Chat Completions** en streaming (SSE) via `POST {baseURL}/chat/completions`
+- **Découverte de modèles** live depuis `GET {baseURL}/models`
+- **Clé API optionnelle** (`LEMONADE_API_KEY`) — utile seulement quand le
+  serveur est configuré avec authentification
+- Support **vision** : les blocs image du Harness sont envoyés en `image_url`
+  (data URL) aux modèles `vision`
+- **Tool calling** au format OpenAI standard
+
+## Prérequis
+
+- Un Lemonade Server en cours d'exécution (par défaut `http://localhost:13305`)
+- Node.js ≥ 22
+- Une installation dsh (profil), par ex. le profil `web`
+
+> Le paquet doit être **compilé au préalable** : `pnpm install && pnpm build`
+> (volet « Développement » ci-dessous) — dsh charge le code depuis `lib/`.
+
+## Installation dans un profil
+
+Depuis le répertoire du profil (ex. `~/.dsh/profiles/web`) :
+
+```sh
+pnpm add file:../dsh-lemonade-provider
+```
+
+ou, en ligne de commande dsh :
+
+```sh
+dsh plugin --profile web add file:../dsh-lemonade-provider
+```
+
+Ajoutez ensuite une entrée dans `cordis.patch.yml` du profil (voir
+[exemple/cordis.patch.yml](exemple/cordis.patch.yml)) :
+
+```yaml
+- id: llm-lemonade
+  name: 'llm-lemonade'
+  config:
+    baseURL: http://localhost:13305
+```
+
+> `baseURL` est la racine du serveur (un suffixe `/v1` d'anciennes configs est
+> supporté). Si `LEMONADE_BASE_URL` est définie, elle est utilisée quand
+> `baseURL` est omise.
+
+## Configuration
+
+| Champ | Type | Défaut | Description |
+| --- | --- | --- | --- |
+| `baseURL` | string | `http://localhost:13305` (ou `LEMONADE_BASE_URL`) | Normalisée à `scheme://host/api` — `/api` ajouté si manquant, `/v1/…` ajouté par endpoint |
+| `apiKeyEnv` | string (credential-ref) | `LEMONADE_API_KEY` | Clé régulière (endpoints /v1/*) |
+| `adminApiKeyEnv` | string (credential-ref) | `LEMONADE_ADMIN_API_KEY` | Clé admin optionnelle (endpoints internes /internal/* et /metrics) |
+| `requireAuth` | boolean | `false` | Échouer quand la clé est absente (distant protégé) |
+| `models` | array | `[]` | Catalogue advisory épinglé par l'utilisateur |
+| `defaultContextWindow` | number | `32768` | Fenêtre de contexte utilisée quand le serveur n'en déclare pas |
+| `maxTokens` | number | `8192` | Cap de sortie par défaut |
+| `streamIdleTimeoutMs` | number | `300000` | Timeout d'inactivité du flux SSE |
+| `retryPolicy` | object | valeurs par défaut | Politique de retry du provider |
+
+Chaque entrée dans `models` : `id` (obligatoire), `name`, `description`,
+`contextWindow`, `maxTokens`, `vision` (boolean).
+
+## Découverte des modèles
+
+La page Modèles du Harness peut interroger `GET {baseURL}/models` via la
+discovery enregistrée pour l'espace de réglages `llm-lemonade`. Les modèles
+non-téléchargés et ceux routés vers d'autres endpoints (embeddings, image,
+TTS, transcription, …) sont exclus de la liste proposée ; la fenêtre de
+contexte déclarée (`max_context_window`) est reprise quand elle est présente.
+
+## Configuration UI (Settings → Models)
+
+La page Settings/Models de dsh n'a pas de porte de sortie tierce : son éditeur ne
+connaît que les namespaces `llm-deepseek` et `llm-pi-ai`. Le plugin branche donc
+sa carte d'édition sur la carte `pi-ai` de la page Models via un patch ponctuel
+du bundle vendu `dsh-client-ui-settings-models` (route `llm-lemonade` → famille
+`pi-ai`). Après toute réinstallation du cache npm (`npm exec`), relancer :
+
+```sh
+node scripts/patch-models-ui.mjs
+node scripts/patch-models-ui-admin.mjs
+```
+
+Le formulaire (Settings → Models -> ligne Lemonade) permet de saisir la clé API
+(optionnelle, stockée via le service credentials sous `LEMONADE_API_KEY`),
+la **clé admin optionnelle** (`LEMONADE_ADMIN_API_KEY` — endpoints internes
+`/internal/*` et `/metrics`, via le patch `patch-models-ui-admin.mjs`),
+la base URL (repli « customized »), et de sélectionner les modèles servis par
+Lemonade via « Fetch available models » (découverte `llm.discoverModels`).
+
+## Vue « Lemonade » (onglet de la conversation)
+
+Un onglet **Lemonade** (à côté de Chat/Trajectory) expose les points d'entrée de
+l'API spécifique Lemonade (health/liveness, télémétrie, modèles avec
+Load/Unload/Delete/Fichiers/MAJ, téléchargements contrôlables, et clés cloud).
+Le navigateur appelle le serveur dsh en même origine (`/dsh-lemonade/api/<op>`) ;
+le host proxi vers Lemonade (`src/server-api.ts`) en résolvant baseURL + clé
+(ceux-ci ne quittent jamais le host). La sélection de la clé est **par endpoint** : les endpoints réguliers (/v1/*, /live) s'authentifient avec `LEMONADE_API_KEY`, et les endpoints de contrôle (`/internal/*`, `/metrics`) avec `LEMONADE_ADMIN_API_KEY` (avec repli sur la clé régulière). La route est enregistrée via
+`ctx.webServer.register({ kind: 'prefix', path: '/dsh-lemonade/api', ... })`
+quand le service `webServer` est disponible.
+
+### Bundle client navigateur
+
+La moitié navigateur vit dans `src/client/index.js` et est copiée telle quelle
+vers `lib/client.js` par le build (`scripts/copy-client.mjs`). Le bundle
+s'enregistre auprès du module loader sous le **nom du paquet** —
+`@cyrilmarin/dsh-lemonade` — car le harness identifie les modules client des plugins
+par leur nom de paquet dans son manifeste de boot :
+
+```js
+window.__ModuleLoader__.load({ id: "@cyrilmarin/dsh-lemonade", factory: (require) => { /* … */ } })
+```
+
+L'id d'enregistrement doit correspondre exactement à l'id de la ligne du graphe ;
+en cas de désaccord, le harness échoue avec *« loaded without registering
+`<id>` via `__ModuleLoader__.load` »*. Comme `lib/` est ignoré par git (sortie de
+build), pensez toujours à reconstruire après toute modification de
+`src/client/index.js` et à réinstaller le paquet dans le profil avant de
+recharger le GUI.
+
+## Développement
+
+```sh
+pnpm install
+pnpm build      # compile TypeScript vers lib/
+pnpm test       # tests du protocole (serveur SSE simulé)
+```
+
+### Structure
+
+- `src/index.ts` — plugin : schéma de config, `apply`, découverte, credentials
+- `src/adapter.ts` — `LemonadeAdapter extends LlmAdapter` (fetch + SSE)
+- `src/serialize.ts` — messages Harness → filaire OpenAI
+- `src/translate.ts` — payloads SSE → chunks `StreamChunk`
+- `src/client/index.js` — moitié navigateur (onglet Lemonade), copiée vers `lib/client.js`
+- `test/adapter.test.mjs` — suite de tests sans dépendance (mock HTTP)
+
+### Licence
+
+MIT
+
+## Release
+
+L'automatisation de release est un script autonome sans dépendance tierce :
+`scripts/release.mjs`. Commandes disponibles :
+
+```sh
+pnpm release:dry      # affiche le plan (aucun fichier écrit, aucune commande git mutative)
+pnpm release          # détecte l'incrément depuis les commits conventionnels
+pnpm release:major    # force un bump major
+pnpm release:minor    # force un bump minor
+pnpm release:patch    # force un bump patch
+```
+
+Le script de release :
+
+1. Détermine l'incrément depuis les commits conventionnels entre le dernier
+   tag (ou tout l'historique s'il n'y a aucun tag) et HEAD :
+
+   | Commit | Bump |
+   | --- | --- |
+   | sujet `type(scope)!: …` ou `BREAKING CHANGE:` dans le corps | major |
+   | `feat` | minor |
+   | `fix`, `perf` | patch |
+   | tout autre commit non encore tagué | patch (fallback) |
+
+   S'il n'y a aucun commit à publier, il affiche un message et sort avec le
+   code 0 sans rien faire.
+2. Incrémente `version` dans `package.json` (un suffixe pré-release, s'il en
+   existe un, est retiré — la release est finale).
+3. Commite `chore(release): <version>` (ne stage que `package.json`).
+4. Crée le tag annoté `v<version>` (préfixe configurable via `--tag-prefix`).
+5. Pousse la branche courante et le tag vers `origin` (omis avec `--no-push`).
+
+> La publication npm proprement dite n'est pas réalisée par le script : elle
+> est déclenchée par la GitHub Release créée sur le tag poussé (workflow
+> [.github/workflows/publish.yml](.github/workflows/publish.yml)).

package/README.md

@@ -0,0 +1,189 @@
+# dsh-lemonade-provider
+
+A **dsh** plugin that integrates [Lemonade Server](https://lemonade-server.ai) as
+a model provider for DeepSeek Harness.
+
+Lemonade exposes an OpenAI-compatible API (Chat Completions). This plugin wires
+this API to the Harness's `ctx.llm` service under the **`lemonade`** provider
+route:
+
+- **Chat Completions** streaming (SSE) via `POST {baseURL}/chat/completions`
+- **Model discovery** live from `GET {baseURL}/models`
+- **Optional API key** (`LEMONADE_API_KEY`) — only needed when
+  the server is configured with authentication
+- **Vision support**: Harness image blocks are sent as `image_url`
+  (data URL) to `vision` models
+- **Tool calling** in standard OpenAI format
+
+## Prerequisites
+
+- A running Lemonade Server (default `http://localhost:13305`)
+- Node.js ≥ 22
+- A dsh installation (profile), e.g. the `web` profile
+
+> The package must be **built beforehand**: `pnpm install && pnpm build`
+> ("Development" section below) — dsh loads code from `lib/`.
+
+## Installation in a profile
+
+From the profile directory (e.g. `~/.dsh/profiles/web`):
+
+```sh
+pnpm add file:../dsh-lemonade-provider
+```
+
+Or, via the dsh command line:
+
+```sh
+dsh plugin --profile web add file:../dsh-lemonade-provider
+```
+
+Then add an entry to the profile's `cordis.patch.yml` (see
+[example/cordis.patch.yml](example/cordis.patch.yml)):
+
+```yaml
+- id: llm-lemonade
+  name: 'llm-lemonade'
+  config:
+    baseURL: http://localhost:13305
+```
+
+> `baseURL` is the server root (an old `/v1` suffix from legacy configs is also
+> supported). If `LEMONADE_BASE_URL` is set, it is used when `baseURL` is omitted.
+
+## Configuration
+
+| Field | Type | Default | Description |
+| --- | --- | --- | --- |
+| `baseURL` | string | `http://localhost:13305` (or `LEMONADE_BASE_URL`) | Normalized to `scheme://host/api` — `/api` appended if missing, `/v1/…` appended per endpoint |
+| `apiKeyEnv` | string (credential-ref) | `LEMONADE_API_KEY` | Regular API key (for /v1/* endpoints) |
+| `adminApiKeyEnv` | string (credential-ref) | `LEMONADE_ADMIN_API_KEY` | Optional admin API key (for internal /internal/* and /metrics endpoints) |
+| `requireAuth` | boolean | `false` | Fail when the key is absent (protected remote) |
+| `models` | array | `[]` | User-pinned advisory model catalog |
+| `defaultContextWindow` | number | `32768` | Context window used when the server doesn't declare one |
+| `maxTokens` | number | `8192` | Default output cap |
+| `streamIdleTimeoutMs` | number | `300000` | SSE stream idle timeout |
+| `retryPolicy` | object | default values | Provider retry policy |
+
+Each entry in `models`: `id` (required), `name`, `description`,
+`contextWindow`, `maxTokens`, `vision` (boolean).
+
+## Model Discovery
+
+The Harness Models page can query `GET {baseURL}/models` through the
+discovery registered for the `llm-lemonade` settings namespace. Undownloaded
+models and those routed to other endpoints (embeddings, image,
+TTS, transcription, …) are excluded from the proposed list; the declared
+context window (`max_context_window`) is reused when present.
+
+## UI Configuration (Settings → Models)
+
+The dsh Settings/Models page has no third-party exit gate: its editor only
+knows the `llm-deepseek` and `llm-pi-ai` namespaces. The plugin therefore wires
+its edit card to the `pi-ai` card on the Models page through a targeted patch
+of the bundled `dsh-client-ui-settings-models` bundle (`llm-lemonade` route →
+`pi-ai` family). After any npm cache reinstallation (`npm exec`), rerun:
+
+```sh
+node scripts/patch-models-ui.mjs
+node scripts/patch-models-ui-admin.mjs
+```
+
+The form (Settings → Models -> Lemonade row) allows entering the API key
+(optional, stored via the credentials service under `LEMONADE_API_KEY`),
+the **optional admin key** (`LEMONADE_ADMIN_API_KEY` — internal endpoints
+`/internal/*` and `/metrics`, via the `patch-models-ui-admin.mjs` patch),
+the base URL (falling back to "customized"), and selecting models served by
+Lemonade via "Fetch available models" (`llm.discoverModels`).
+
+## Lemonade View (Conversation Tab)
+
+A **Lemonade** tab (next to Chat/Trajectory) exposes the entry points of the
+Lemonade-specific API (health/liveness, telemetry, models with
+Load/Unload/Delete/Files/Update, controllable downloads, and cloud keys).
+The browser calls the dsh server on the same origin (`/dsh-lemonade/api/<op>`);
+the host proxy to Lemonade (`src/server-api.ts`) resolves baseURL + key
+(these never leave the host). Key selection is **per endpoint**: regular
+endpoints (/v1/*, /live) authenticate with `LEMONADE_API_KEY`, and control
+endpoints (`/internal/*`, `/metrics`) with `LEMONADE_ADMIN_API_KEY` (falling
+back to the regular key). The route is registered via
+`ctx.webServer.register({ kind: 'prefix', path: '/dsh-lemonade/api', ... })`
+when the `webServer` service is available.
+
+### Client browser bundle
+
+The browser half lives in `src/client/index.js` and is copied verbatim to
+`lib/client.js` by the build (`scripts/copy-client.mjs`). The bundle registers
+itself with the module loader under the **package name** — `@cyrilmarin/dsh-lemonade`
+— because the harness keys plugin client modules by package name in its boot
+manifest:
+
+```js
+window.__ModuleLoader__.load({ id: "@cyrilmarin/dsh-lemonade", factory: (require) => { /* … */ } })
+```
+
+The registration id must match the graph row id exactly; a mismatch makes the
+harness fail with *"loaded without registering `<id>` via `__ModuleLoader__.load`"*.
+Because `lib/` is gitignored (build output), always rebuild after touching
+`src/client/index.js` and reinstall the package in the profile before reloading
+the GUI.
+
+## Development
+
+```sh
+pnpm install
+pnpm build      # compile TypeScript to lib/
+pnpm test       # protocol tests (simulated SSE server)
+```
+
+### Structure
+
+- `src/index.ts` — plugin: config schema, `apply`, discovery, credentials
+- `src/adapter.ts` — `LemonadeAdapter extends LlmAdapter` (fetch + SSE)
+- `src/serialize.ts` — Harness messages → OpenAI wire format
+- `src/translate.ts` — SSE payloads → `StreamChunk` chunks
+- `src/client/index.js` — browser half (Lemonade conversation tab), copied to `lib/client.js`
+- `test/adapter.test.mjs` — dependency-free test suite (mock HTTP)
+
+### License
+
+MIT
+
+## Release
+
+Release automation is a self-contained script with no third-party dependency:
+`scripts/release.mjs`. Available commands:
+
+```sh
+pnpm release:dry      # show the plan (no file writes, no mutating git commands)
+pnpm release          # auto-detect the bump from the conventional commits
+pnpm release:major    # force a major bump
+pnpm release:minor    # force a minor bump
+pnpm release:patch    # force a patch bump
+```
+
+The release script:
+
+1. Determines the increment from the conventional commits between the last
+   tag (or the full history when no tag exists) and HEAD:
+
+   | Commit | Bump |
+   | --- | --- |
+   | `type(scope)!: …` subject or `BREAKING CHANGE:` in the body | major |
+   | `feat` | minor |
+   | `fix`, `perf` | patch |
+   | any other commit not yet tagged | patch (fallback) |
+
+   With no commit to publish, it prints a message and exits 0 without doing
+   anything.
+2. Bumps `version` in `package.json` (a prerelease suffix, if present, is
+   dropped — the release is final).
+3. Commits `chore(release): <version>` (stages `package.json` only).
+4. Creates the annotated tag `v<version>` (prefix configurable via
+   `--tag-prefix`).
+5. Pushes the current branch and the tag to `origin` (omitted with
+   `--no-push`).
+
+> The npm publication itself is not performed by the script: it is triggered
+> by the GitHub Release created on the pushed tag (workflow
+> [.github/workflows/publish.yml](.github/workflows/publish.yml)).

package/lib/adapter.js

@@ -0,0 +1,287 @@
+import { CONTEXT_WINDOW_EXCEEDED_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, attributionHeaders, isContextWindowExceededError, isQuotaExceededError, } from '@deepseek-ai/dsh-llm';
+import { idleWatchdog, timeoutOf } from '@deepseek-ai/dsh-timeout';
+import { serializeRequest } from './serialize.js';
+import { parseSse, translate } from './translate.js';
+/** Default endpoint (baseURL is the server root; /v1 paths are appended by each endpoint builder). */
+export const DEFAULT_BASE_URL = 'http://localhost:13305';
+/** Default combined request/response context capacity for models with no metadata. */
+export const DEFAULT_CONTEXT_WINDOW = 32768;
+/** Default per-request output-token cap. */
+export const DEFAULT_MAX_TOKENS = 8192;
+/** Default maximum idle interval while an adapter stream read is outstanding. */
+export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 5 * 60_000;
+/** Maximum time one live model-listing query may take. */
+export const LISTING_TIMEOUT_MS = 5_000;
+const STREAM_IDLE_TIMEOUT_CODE = 'LLM_STREAM_IDLE_TIMEOUT';
+/**
+ * Deployment labels that route a model to a non-chat endpoint; such models are
+ * excluded from the chat model listing. Characteristic labels (vision,
+ * reasoning, tool-calling, …) and chat-capable modality labels are kept.
+ */
+const NON_CHAT_LABELS = new Set(['transcription', 'embeddings', 'reranking', 'image', 'edit', 'tts']);
+/** Map an HTTP status to a stable LlmError code. */
+function httpErrorCode(status, error) {
+    if (status === 401 || status === 403)
+        return 'AUTH';
+    const detail = [error?.code, error?.type, error?.message].filter(Boolean).join(' ');
+    if (isQuotaExceededError(detail))
+        return QUOTA_EXCEEDED_CODE;
+    if (status === 429)
+        return 'RATE_LIMIT';
+    if (status === 400) {
+        if (isContextWindowExceededError(detail))
+            return CONTEXT_WINDOW_EXCEEDED_CODE;
+        return 'INVALID_REQUEST';
+    }
+    if (status >= 500)
+        return 'SERVER';
+    return `HTTP_${status}`;
+}
+function providerRetryAfterMs(value) {
+    if (value === null)
+        return undefined;
+    if (/^\d+$/.test(value)) {
+        const delay = Number(value) * 1_000;
+        return Number.isFinite(delay) && delay > 0 ? delay : undefined;
+    }
+    const delay = Date.parse(value) - Date.now();
+    return Number.isFinite(delay) && delay > 0 ? delay : undefined;
+}
+function requestId(headers) {
+    const value = headers.get('x-request-id') ?? headers.get('x-lemonade-request-id');
+    return value === null || value.length === 0 ? undefined : ProviderRequestId(value);
+}
+/**
+ * Read one Lemonade model listing, filtering out models that are not chat
+ * completions targets (non-downloaded entries, and entries whose deployment
+ * labels route them to another endpoint).
+ */
+export async function fetchModelEntries(baseURL, apiKey, signal) {
+    const url = `${baseURL}/v1/models`;
+    const headers = { accept: 'application/json', ...attributionHeaders() };
+    if (apiKey !== undefined)
+        headers.authorization = `Bearer ${apiKey}`;
+    let response;
+    try {
+        response = await fetch(url, { method: 'GET', headers, signal });
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw new LlmError('model discovery aborted by caller', 'ABORTED', { cause: error });
+        throw new LlmError(`could not reach ${url}`, 'DISCOVERY_FAILED', { cause: error });
+    }
+    if (!response.ok) {
+        throw new LlmError(`${url} answered ${response.status}${response.status === 401 || response.status === 403 ? '; check the API key' : ''}`, 'DISCOVERY_FAILED');
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch (error) {
+        throw new LlmError(`${url} did not answer with JSON`, 'DISCOVERY_FAILED', { cause: error });
+    }
+    const data = body?.data;
+    if (!Array.isArray(data)) {
+        throw new LlmError(`${url} has no "data" array; enter this server's models by hand`, 'DISCOVERY_FAILED');
+    }
+    const entries = [];
+    const seen = new Set();
+    for (const raw of data) {
+        const record = (raw ?? {});
+        const id = typeof record['id'] === 'string' ? record['id'] : '';
+        if (id.length === 0 || seen.has(id))
+            continue;
+        // Skip alias entries (Lemonade Server exposes model aliases alongside real
+        // models; an alias has a "model" field pointing to its target).
+        if (typeof record['model'] === 'string' && record['model'].length > 0)
+            continue;
+        if (record['downloaded'] === false)
+            continue;
+        const labels = Array.isArray(record['labels'])
+            ? record['labels'].filter((label) => typeof label === 'string')
+            : [];
+        if (labels.some((label) => NON_CHAT_LABELS.has(label)))
+            continue;
+        seen.add(id);
+        const maxContextWindow = typeof record['max_context_window'] === 'number' && record['max_context_window'] > 0
+            ? record['max_context_window']
+            : undefined;
+        entries.push({
+            id,
+            ...(maxContextWindow !== undefined ? { maxContextWindow } : {}),
+            ...(labels.length > 0 ? { labels } : {}),
+            ...(labels.includes('vision') ? { vision: true } : {}),
+        });
+    }
+    return entries;
+}
+/**
+ * Interrogate one Lemonade endpoint for the models it advertises, mapped to
+ * the harness discovery vocabulary (id + optional context window).
+ */
+export async function discoverModels(baseURL, apiKey, signal) {
+    const entries = await fetchModelEntries(baseURL, apiKey, signal);
+    return entries.map((entry) => ({
+        id: entry.id,
+        ...(entry.maxContextWindow !== undefined ? { contextWindow: entry.maxContextWindow } : {}),
+    }));
+}
+/** Build display metadata for one model. */
+function modelInfo(provider, id, live, configured) {
+    return {
+        provider,
+        id,
+        name: configured?.name ?? id,
+        ...(configured?.description !== undefined ? { description: configured.description } : {}),
+        inputModalities: live?.vision === true || configured?.vision === true ? ['text', 'image'] : ['text'],
+    };
+}
+/**
+ * The Lemonade adapter. One instance serves every model name it is registered
+ * under (the harness model name IS the wire model name).
+ *
+ * One stable signal reaches both the initial fetch and the body reads. Caller
+ * aborts map to `ABORTED`; the configured per-read idle watchdog maps to `TIMEOUT`.
+ */
+export class LemonadeAdapter extends LlmAdapter {
+    config;
+    /** The most recent successful live listing, keyed by model id (advisory cache, never authoritative). */
+    lastKnown = new Map();
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    providerInfo(provider) {
+        return { id: provider, name: 'Lemonade' };
+    }
+    providerRetryPolicy(_provider) {
+        return this.config.options().retryPolicy;
+    }
+    async listModels(provider) {
+        const options = this.config.options();
+        // The configured catalog IS the selection: when models are pinned in the
+        // plugin configuration, the model selector offers ONLY those.
+        if (options.models.length > 0) {
+            return options.models.map((model) => modelInfo(provider, model.id, undefined, model));
+        }
+        // No configured selection: advertise whatever the server currently offers.
+        try {
+            const apiKey = await this.config.resolveApiKey();
+            const entries = await fetchModelEntries(options.baseURL, apiKey, AbortSignal.timeout(LISTING_TIMEOUT_MS));
+            this.lastKnown = new Map(entries.map((entry) => [entry.id, entry]));
+            return entries.map((entry) => modelInfo(provider, entry.id, entry));
+        }
+        catch {
+            return [];
+        }
+    }
+    async resolveModel(provider, model, _signal) {
+        const options = this.config.options();
+        const configured = options.models.find((entry) => entry.id === model);
+        const live = this.lastKnown.get(model);
+        const contextWindow = configured?.contextWindow ?? live?.maxContextWindow ?? options.defaultContextWindow;
+        return {
+            ...modelInfo(provider, model, live, configured),
+            context: { contextWindow },
+            defaultMaxTokens: configured?.maxTokens ?? options.maxTokens,
+        };
+    }
+    async *stream(options) {
+        const connection = this.config.options();
+        const apiKey = await this.config.resolveApiKey();
+        const consumer = new AbortController();
+        const watchdog = idleWatchdog(options.signal === undefined ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]), connection.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE);
+        const iterator = this.request(options, watchdog.signal, connection, apiKey, () => watchdog.pulse())[Symbol.asyncIterator]();
+        let exhausted = false;
+        try {
+            while (true) {
+                const result = await watchdog.next(iterator);
+                if (result.done) {
+                    exhausted = true;
+                    return;
+                }
+                yield result.value;
+            }
+        }
+        catch (error) {
+            if (timeoutOf(watchdog.signal, STREAM_IDLE_TIMEOUT_CODE) !== undefined) {
+                throw new LlmError(`Lemonade stream idle timeout after ${connection.streamIdleTimeoutMs}ms`, 'TIMEOUT', { cause: error });
+            }
+            if (options.signal?.aborted)
+                throw new LlmError('Lemonade request aborted by caller', 'ABORTED', { cause: error });
+            if (error instanceof LlmError)
+                throw error;
+            throw new LlmError(`Lemonade API stream from ${connection.baseURL} failed`, 'TRANSPORT', { cause: error });
+        }
+        finally {
+            consumer.abort('Lemonade stream consumer stopped');
+            watchdog[Symbol.dispose]();
+            if (!exhausted && iterator.return !== undefined) {
+                try {
+                    await iterator.return(undefined);
+                }
+                catch {
+                    // transport teardown — the streaming error (if any) already surfaced above
+                }
+            }
+        }
+    }
+    /** Build the image resolver from the mounted attachment service, if any. */
+    async resolveImage(signal) {
+        const attachments = this.config.resolveAttachments();
+        if (attachments === undefined)
+            return undefined;
+        return async (ref) => {
+            const stored = await attachments.readImage(ref, signal);
+            const base64 = Buffer.from(stored.data).toString('base64');
+            return `data:${stored.ref.mediaType};base64,${base64}`;
+        };
+    }
+    async *request(options, signal, connection, apiKey, onComment) {
+        const resolveImage = await this.resolveImage(signal);
+        const body = await serializeRequest(options, resolveImage);
+        const headers = {
+            'content-type': 'application/json',
+            accept: 'text/event-stream',
+            ...attributionHeaders(),
+            ...(apiKey !== undefined ? { authorization: `Bearer ${apiKey}` } : {}),
+        };
+        const url = `${connection.baseURL}/v1/chat/completions`;
+        let response;
+        try {
+            response = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body), signal });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            throw new LlmError(`Lemonade API request to ${url} failed`, 'TRANSPORT', { cause: error });
+        }
+        if (!response.ok) {
+            let message = `Lemonade API error (HTTP ${response.status})`;
+            let providerError;
+            try {
+                const parsed = await response.json();
+                if (parsed && typeof parsed === 'object' && parsed.error && typeof parsed.error === 'object') {
+                    providerError = parsed.error;
+                    if (typeof providerError.message === 'string' && providerError.message.length > 0) {
+                        message = providerError.message;
+                    }
+                }
+            }
+            catch {
+                // no parseable error body — keep the generic message
+            }
+            const delay = providerRetryAfterMs(response.headers.get('retry-after'));
+            const id = requestId(response.headers);
+            throw new LlmError(message, httpErrorCode(response.status, providerError), {
+                status: response.status,
+                ...(delay !== undefined ? { providerRetryAfterMs: delay } : {}),
+                ...(id !== undefined ? { requestId: id } : {}),
+            });
+        }
+        if (!response.body)
+            throw new LlmError('Lemonade API returned no response body', 'EMPTY_RESPONSE');
+        yield* translate(parseSse(response.body, onComment));
+    }
+}
+//# sourceMappingURL=adapter.js.map