@cyrilmarin/dsh-lemonade 0.2.1

package/lib/server-api.js

@@ -0,0 +1,356 @@
+import { attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { deadline, timeoutOf } from '@deepseek-ai/dsh-timeout';
+/** Route prefix registered on ctx.webServer. */
+export const API_ROUTE = '/dsh-lemonade/api';
+/** Maximum accepted request body and proxied response body in bytes. */
+export const MAX_BODY_BYTES = 1_000_000;
+/** Fetch timeout for proxied Lemonade calls. */
+export const API_TIMEOUT_MS = 10_000;
+const TIMEOUT_CODE = 'LEMONADE_API_TIMEOUT';
+const okResult = (value) => ({ ok: true, value });
+const errResult = (message, code, status) => ({
+    ok: false,
+    error: { message, code, ...(status === undefined ? {} : { status }) },
+});
+/** Map a Lemonade HTTP status to a stable harness-style code. */
+export function mapLemonadeStatus(status) {
+    if (status === 401 || status === 403)
+        return 'AUTH';
+    if (status === 429)
+        return 'RATE_LIMIT';
+    if (status === 409)
+        return 'CONFLICT';
+    if (status === 400)
+        return 'INVALID_REQUEST';
+    if (status >= 500)
+        return 'SERVER';
+    return 'HTTP_' + status;
+}
+/** Client-input error normalized to a wire result. */
+/** Ops that target internal/control endpoints, authenticated with the admin key. */
+const ADMIN_OPS = new Set([
+    'metrics',
+    'internalTelemetryFlush',
+    'internalAliases',
+    'internalAliasesSet',
+    'internalAliasesDelete',
+]);
+const isAdminOp = (op) => ADMIN_OPS.has(op);
+class RequestError extends Error {
+    code;
+    status;
+    constructor(message, code, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+/** Build the stable Lemonade endpoint for one op. */
+function resolveTarget(op, args, query, body) {
+    const record = asRecord(body);
+    const pick = (keys) => {
+        const out = {};
+        for (const key of keys)
+            if (record[key] !== undefined)
+                out[key] = record[key];
+        return out;
+    };
+    const qs = (extra) => {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(extra)) {
+            if (value !== undefined && value.length > 0)
+                params.set(key, value);
+        }
+        const text = params.toString();
+        return text.length > 0 ? '?' + text : '';
+    };
+    const str = (value) => (typeof value === 'string' && value.length > 0 ? value : undefined);
+    /**
+     * The Lemonade model-management endpoints take the model id under
+     * `model_name` (the spec: load/unload/delete). This client historically sent
+     * `model`; accept both and forward the canonical `model_name`.
+     */
+    const modelName = () => {
+        const named = record.model_name;
+        if (typeof named === 'string' && named.length > 0)
+            return named;
+        const alias = record.model;
+        return typeof alias === 'string' && alias.length > 0 ? alias : undefined;
+    };
+    switch (op) {
+        case 'health': return { method: 'GET', url: '/v1/health' };
+        case 'live': return { method: 'GET', url: '/live' };
+        case 'models':
+            return { method: 'GET', url: '/v1/models' + qs({ show_all: str(query.get('show_all') ?? record.show_all) }) };
+        case 'modelFiles': {
+            const id = args[0];
+            if (id === undefined || id.length === 0)
+                throw new RequestError('model id required', 'INVALID_REQUEST', 400);
+            return { method: 'GET', url: '/v1/models/' + encodeURIComponent(id) + '/files' };
+        }
+        case 'load': {
+            const mn = modelName();
+            if (mn === undefined)
+                throw new RequestError('model required', 'INVALID_REQUEST', 400);
+            return {
+                method: 'POST',
+                url: '/v1/load',
+                body: {
+                    model_name: mn,
+                    ...pick(['pinned', 'save_options', 'ctx_size', 'llamacpp_backend', 'llamacpp_args', 'whispercpp_backend', 'whispercpp_args', 'steps', 'cfg_scale', 'width', 'height', 'merge_args']),
+                },
+            };
+        }
+        case 'unload': {
+            const mn = modelName();
+            // model_name optional: omitted unloads every loaded model (spec).
+            return { method: 'POST', url: '/v1/unload', body: mn === undefined ? {} : { model_name: mn } };
+        }
+        case 'delete': {
+            const mn = modelName();
+            if (mn === undefined)
+                throw new RequestError('model required', 'INVALID_REQUEST', 400);
+            return { method: 'POST', url: '/v1/delete', body: { model_name: mn } };
+        }
+        case 'checkUpdates': return { method: 'POST', url: '/v1/models/check-updates' };
+        case 'registrySearch':
+            return {
+                method: 'GET',
+                url: '/v1/registry/search' + qs({
+                    query: str(query.get('query') ?? query.get('q') ?? record.query),
+                    source: str(query.get('source') ?? record.source),
+                    format: str(query.get('format') ?? record.format),
+                    limit: str(query.get('limit') ?? (record.limit !== undefined ? String(record.limit) : undefined)),
+                }),
+            };
+        case 'pullVariants':
+            return {
+                method: 'GET',
+                url: '/v1/pull/variants' + qs({
+                    checkpoint: str(query.get('checkpoint') ?? record.checkpoint),
+                }),
+            };
+        case 'pull':
+            // Spec: model_name (Yes, user.* namespace), recipe (Yes), checkpoint (Yes*),
+            // plus checkpoints dict, reasoning/vision/embedding/reranking, mmproj.
+            return {
+                method: 'POST',
+                url: '/v1/pull',
+                body: pick(['model_name', 'recipe', 'checkpoint', 'checkpoints', 'reasoning', 'vision', 'embedding', 'reranking', 'mmproj', 'stream', 'subscribe']),
+            };
+        case 'downloads': return { method: 'GET', url: '/v1/downloads' };
+        case 'downloadsControl': return { method: 'POST', url: '/v1/downloads/control', body: pick(['id', 'action']) };
+        case 'stats': return { method: 'GET', url: '/v1/stats' };
+        case 'systemStats': return { method: 'GET', url: '/v1/system-stats' };
+        case 'systemInfo': return { method: 'GET', url: '/v1/system-info' };
+        case 'cloudAuthSet': return { method: 'POST', url: '/v1/cloud/auth', body: pick(['provider', 'api_key']) };
+        case 'cloudAuthDelete': {
+            const provider = args[0];
+            if (provider === undefined || provider.length === 0)
+                throw new RequestError('provider required', 'INVALID_REQUEST', 400);
+            return { method: 'DELETE', url: '/v1/cloud/auth/' + encodeURIComponent(provider) };
+        }
+        // Admin / internal endpoints (authenticated with the admin API key).
+        case 'metrics':
+            return { method: 'GET', url: '/metrics' };
+        case 'internalTelemetryFlush':
+            return { method: 'POST', url: '/internal/telemetry/flush' };
+        case 'internalAliases':
+            return { method: 'GET', url: '/internal/aliases' };
+        case 'internalAliasesSet':
+            return { method: 'POST', url: '/internal/aliases', body: pick(['alias', 'target', 'model']) };
+        case 'internalAliasesDelete': {
+            const alias = args[0];
+            if (alias === undefined || alias.length === 0)
+                throw new RequestError('alias required', 'INVALID_REQUEST', 400);
+            return { method: 'DELETE', url: '/internal/aliases/' + encodeURIComponent(alias) };
+        }
+        default: throw new RequestError('unknown Lemonade api op: ' + op, 'NOT_FOUND', 404);
+    }
+}
+async function readResponseText(response) {
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength > MAX_BODY_BYTES)
+        return { text: '', tooLarge: true };
+    return { text: new TextDecoder().decode(buffer), tooLarge: false };
+}
+/**
+ * Dispatch one proxied Lemonade API call.
+ * @param cfg - connection facts (thunks resolved per call).
+ * @param method - HTTP method from the client (GET/POST/DELETE).
+ * @param op - first path segment after the route prefix.
+ * @param segments - remaining path segments after the route prefix.
+ * @param query - parsed query string.
+ * @param body - parsed request body (undefined when none).
+ * @param signal - optional caller cancellation.
+ */
+export async function serveLemonadeApi(cfg, method, op, args, query, body, signal) {
+    let target;
+    try {
+        target = resolveTarget(op, args, query, body);
+    }
+    catch (error) {
+        if (error instanceof RequestError)
+            return errResult(error.message, error.code, error.status);
+        throw error;
+    }
+    if (method !== target.method) {
+        return errResult('method ' + method + ' not allowed for ' + op + ' (expected ' + target.method + ')', 'METHOD_NOT_ALLOWED', 405);
+    }
+    // Per-endpoint key selection: internal/control endpoints (/internal/*, /metrics)
+    // authenticate with the admin key (falling back to the regular key, which
+    // lemonade accepts for /metrics); regular endpoints use the regular key (the
+    // admin key is a superior credential and also works when it is the only one set).
+    const admin = isAdminOp(op);
+    const regularKey = await cfg.resolveKey(cfg.apiKeyRef());
+    const adminKey = await cfg.resolveKey(cfg.adminApiKeyRef());
+    const apiKey = admin ? (adminKey ?? regularKey) : (regularKey ?? adminKey);
+    if (!admin && apiKey === undefined && cfg.requireAuth()) {
+        return errResult('llm-lemonade: the Lemonade server requires a key (requireAuth) and none is set; store LEMONADE_API_KEY or LEMONADE_ADMIN_API_KEY via Settings > Models > Lemonade', 'MISSING_CREDENTIAL');
+    }
+    const configured = (cfg.baseURL() || '').replace(/\/+$/, '').replace(/\/v1$/i, '');
+    // /internal/*, /live and /metrics are ROOT-level (no /api, no /v1) per spec;
+    // everything else is served under the /api prefix.
+    const isRootPath = target.url.startsWith('/internal/') || target.url === '/live' || target.url === '/metrics';
+    const base = isRootPath ? configured.replace(/\/api$/i, '') : configured;
+    const url = base + target.url;
+    const headers = { accept: 'application/json', ...attributionHeaders() };
+    if (apiKey !== undefined)
+        headers.authorization = 'Bearer ' + apiKey;
+    if (target.body !== undefined)
+        headers['content-type'] = 'application/json';
+    const timer = deadline(signal, API_TIMEOUT_MS, TIMEOUT_CODE);
+    let response;
+    try {
+        response = await fetch(url, {
+            method: target.method,
+            headers,
+            ...(target.body === undefined ? {} : { body: JSON.stringify(target.body) }),
+            signal: timer.signal,
+        });
+    }
+    catch (error) {
+        if (timeoutOf(timer.signal, TIMEOUT_CODE) !== undefined) {
+            return errResult('Lemonade API timeout after ' + API_TIMEOUT_MS + 'ms', 'TIMEOUT');
+        }
+        if (signal !== undefined && signal.aborted)
+            return errResult('Lemonade request aborted by caller', 'ABORTED');
+        return errResult('could not reach ' + url, 'TRANSPORT');
+    }
+    finally {
+        timer[Symbol.dispose]();
+    }
+    const decoded = await readResponseText(response);
+    if (decoded.tooLarge) {
+        return errResult('Lemonade response exceeds ' + MAX_BODY_BYTES + ' bytes', 'PAYLOAD_TOO_LARGE', 413);
+    }
+    let value = null;
+    if (decoded.text.length > 0) {
+        if (op === 'metrics') {
+            // Prometheus text exposition format, not JSON.
+            value = decoded.text;
+        }
+        else {
+            try {
+                value = JSON.parse(decoded.text);
+            }
+            catch {
+                return errResult('Lemonade answered with non-JSON at ' + url, 'BAD_RESPONSE', 502);
+            }
+        }
+    }
+    if (!response.ok) {
+        let message = 'Lemonade API error (HTTP ' + response.status + ')';
+        if (value !== null && typeof value === 'object') {
+            const record = asRecord(value);
+            const nested = record.error !== null && typeof record.error === 'object' ? asRecord(record.error) : undefined;
+            if (nested && typeof nested.message === 'string' && nested.message.length > 0)
+                message = nested.message;
+            else if (typeof record.message === 'string' && record.message.length > 0)
+                message = record.message;
+        }
+        return errResult(message, mapLemonadeStatus(response.status), response.status);
+    }
+    // Lemonade write endpoints (load/unload/delete/pull) answer HTTP 200 with
+    // { status: 'error', message } on failure; surface it as a wire error.
+    if (value !== null && typeof value === 'object') {
+        const record = value;
+        if (record.status === 'error' && typeof record.message === 'string' && record.message.length > 0) {
+            return errResult(record.message, 'LEMONADE_ERROR', response.status);
+        }
+    }
+    return okResult(value);
+}
+async function readRequestBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES)
+            throw new RequestError('request body exceeds ' + MAX_BODY_BYTES + ' bytes', 'PAYLOAD_TOO_LARGE', 413);
+        chunks.push(chunk);
+    }
+    if (chunks.length === 0)
+        return undefined;
+    const text = Buffer.concat(chunks).toString('utf8');
+    if (text.trim().length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new RequestError('request body is not valid JSON', 'INVALID_REQUEST', 400);
+    }
+}
+function writeJson(res, status, value) {
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+    });
+    res.end(JSON.stringify(value));
+}
+/**
+ * Stream the Lemonade server logs (WS /logs/stream) as newline-delimited JSON
+ * to the browser. The spec: the log WebSocket shares the Realtime Audio port,
+ * discovered via /v1/health (websocket_port) — not the main HTTP port — then
+ * `ws://<host>:<port>/logs/stream`, subscribe with `{ type: 'logs.subscribe',
+ * after_seq: <int|null> }`, and the server answers `logs.snapshot` (up to
+ * 5000 retained entries) then `logs.entry` lines. Messages are relayed as-is
+ * (`{ type: 'logs.snapshot' | 'logs.entry' | 'error', ... }`); the response is
+ * held open and closed when the browser disconnects.
+ */
+/**
+ * Build the node:http handler mounting the Lemonade-specific API proxy at the
+ * /dsh-lemonade/api prefix route (ctx.webServer.register). Never throws out:
+ * every outcome is normalized to a JSON wire result.
+ */
+export function createLemonadeApiHandler(cfg) {
+    return async (req, res) => {
+        let result;
+        try {
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const rest = url.pathname.startsWith(API_ROUTE) ? url.pathname.slice(API_ROUTE.length) : url.pathname;
+            const segments = rest.split('/').filter((part) => part.length > 0);
+            const op = segments[0] ?? '';
+            const args = segments.slice(1);
+            const body = req.method === 'POST' || req.method === 'PUT' || req.method === 'PATCH'
+                ? await readRequestBody(req)
+                : undefined;
+            result = await serveLemonadeApi(cfg, req.method ?? 'GET', op, args, url.searchParams, body);
+        }
+        catch (error) {
+            result =
+                error instanceof RequestError
+                    ? errResult(error.message, error.code, error.status)
+                    : errResult('Lemonade API proxy failed: ' + String(error?.message ?? error), 'SERVER', 500);
+        }
+        const status = result.ok ? 200 : (result.error.status ?? 500);
+        writeJson(res, status, result);
+    };
+}
+//# sourceMappingURL=server-api.js.map

package/lib/translate.js

@@ -0,0 +1,163 @@
+/**
+ * Translate Lemonade's OpenAI-compatible SSE payloads into the harness
+ * `StreamChunk` protocol.
+ *
+ * One stateful block is kept per content, reasoning, or tool-call index; an
+ * empty initial delta does not open a block. Block-ends, usage, and finish are
+ * deferred to the terminal emission at the end of the payload stream, so no
+ * chunk ever follows `finish`.
+ *
+ * Lemonade's docs do not guarantee the `[DONE]` sentinel, so a clean EOF
+ * (the payload iterator simply ends) is treated as a normal completion, unlike
+ * providers that promise the sentinel. `[DONE]`, when present, is consumed
+ * and skipped.
+ *
+ * @module dsh-lemonade-provider/translate
+ */
+import { CallId, EMPTY_RESPONSE_CODE, LlmError } from '@deepseek-ai/dsh-llm';
+import { EventSourceParserStream } from 'eventsource-parser/stream';
+/** Parse an SSE byte stream into its `data` payloads. */
+export async function* parseSse(stream, onComment) {
+    const events = stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream({ onComment }));
+    for await (const { data } of events) {
+        yield data;
+        if (data === '[DONE]')
+            return;
+    }
+}
+/**
+ * Map the wire `finish_reason` vocabulary to the harness FinishReason.
+ * Unrecognized values (content_filter, …) become a severity-typed error
+ * finish with the uppercased value as the code.
+ */
+function mapFinishReason(reason) {
+    switch (reason) {
+        case 'stop': return { kind: 'stop' };
+        case 'tool_calls': return { kind: 'tool-calls' };
+        case 'length': return { kind: 'max-tokens' };
+        default: return { kind: 'error', failure: { message: `model stopped: ${reason}`, code: reason.toUpperCase() } };
+    }
+}
+/**
+ * Map wire usage fields. OpenAI's `prompt_tokens` is a TOTAL that includes
+ * cache hits (`prompt_tokens_details.cached_tokens`); the harness TokenUsage
+ * convention is DISJOINT counts, so cache reads are subtracted out.
+ */
+function mapUsage(usage) {
+    const details = usage['prompt_tokens_details'];
+    const completionDetails = usage['completion_tokens_details'];
+    const cacheRead = typeof details?.['cached_tokens'] === 'number' ? details['cached_tokens'] : undefined;
+    const reasoning = typeof completionDetails?.['reasoning_tokens'] === 'number' ? completionDetails['reasoning_tokens'] : undefined;
+    return {
+        inputTokens: usage['prompt_tokens'] - (cacheRead ?? 0),
+        outputTokens: usage['completion_tokens'],
+        ...(cacheRead !== undefined ? { cacheReadTokens: cacheRead } : {}),
+        ...(reasoning !== undefined ? { reasoningTokens: reasoning } : {}),
+    };
+}
+/** Assemble the final ContentBlock for one open block. */
+function closeBlock(block) {
+    switch (block.kind) {
+        case 'text': return { type: 'text', text: block.text };
+        case 'reasoning': return { type: 'reasoning', text: block.text };
+        case 'tool-call': return {
+            type: 'tool-call',
+            id: CallId(block.callId ?? ''),
+            name: block.name ?? '',
+            arguments: block.text,
+        };
+    }
+}
+/**
+ * Consume SSE data payloads (optionally ending with `[DONE]`) and yield
+ * harness StreamChunks. Malformed JSON payloads abort the stream with
+ * `MALFORMED_RESPONSE`. A `stop` (or absent) finish with no opened blocks is a
+ * degenerate provider completion and maps to an `EMPTY_RESPONSE` error finish.
+ */
+export async function* translate(payloads) {
+    let nextIndex = 0;
+    let textBlock;
+    let reasoningBlock;
+    const toolBlocks = new Map();
+    const order = [];
+    let pendingFinish;
+    let pendingUsage;
+    function open(kind) {
+        const block = { index: nextIndex++, kind, text: '' };
+        order.push(block);
+        return block;
+    }
+    for await (const payload of payloads) {
+        if (payload === '[DONE]')
+            continue;
+        let chunk;
+        try {
+            chunk = JSON.parse(payload);
+        }
+        catch {
+            throw new LlmError(`malformed SSE payload: ${payload.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+        }
+        for (const choice of chunk.choices ?? []) {
+            const delta = choice.delta ?? {};
+            const reasoning = delta.reasoning_content;
+            if (typeof reasoning === 'string' && reasoning.length > 0) {
+                if (!reasoningBlock) {
+                    reasoningBlock = open('reasoning');
+                    yield { type: 'block-start', index: reasoningBlock.index, blockType: 'reasoning' };
+                }
+                reasoningBlock.text += reasoning;
+                yield { type: 'reasoning-delta', index: reasoningBlock.index, text: reasoning };
+            }
+            const content = delta.content;
+            if (typeof content === 'string' && content.length > 0) {
+                if (!textBlock) {
+                    textBlock = open('text');
+                    yield { type: 'block-start', index: textBlock.index, blockType: 'text' };
+                }
+                textBlock.text += content;
+                yield { type: 'text-delta', index: textBlock.index, text: content };
+            }
+            for (const call of delta.tool_calls ?? []) {
+                const callIndex = call.index ?? toolBlocks.size;
+                let block = toolBlocks.get(callIndex);
+                if (!block) {
+                    block = open('tool-call');
+                    toolBlocks.set(callIndex, block);
+                    yield { type: 'block-start', index: block.index, blockType: 'tool-call' };
+                }
+                if (typeof call.id === 'string')
+                    block.callId = call.id;
+                if (typeof call.function?.name === 'string')
+                    block.name = call.function.name;
+                const fragment = typeof call.function?.arguments === 'string' ? call.function.arguments : '';
+                block.text += fragment;
+                yield {
+                    type: 'tool-call-delta',
+                    index: block.index,
+                    id: CallId(block.callId ?? ''),
+                    ...(block.name !== undefined ? { name: block.name } : {}),
+                    argumentsDelta: fragment,
+                };
+            }
+            if (typeof choice.finish_reason === 'string')
+                pendingFinish = mapFinishReason(choice.finish_reason);
+        }
+        if (chunk.usage)
+            pendingUsage = mapUsage(chunk.usage);
+    }
+    // Terminal emission: nothing follows the finish chunk.
+    for (const block of order)
+        yield { type: 'block-end', index: block.index, block: closeBlock(block) };
+    if (pendingUsage)
+        yield { type: 'usage', usage: pendingUsage };
+    const reason = pendingFinish ?? { kind: 'stop' };
+    yield {
+        type: 'finish',
+        reason: reason.kind === 'stop' && order.length === 0
+            ? { kind: 'error', failure: { message: 'model returned a completed response with no content', code: EMPTY_RESPONSE_CODE } }
+            : reason,
+    };
+}
+//# sourceMappingURL=translate.js.map

package/lib/types/adapter.d.ts

@@ -0,0 +1,94 @@
+/**
+ * `LemonadeAdapter`: fetch + SSE against a Lemonade Server (OpenAI-compatible)
+ * chat-completions endpoint, emitting harness StreamChunks.
+ *
+ * The adapter is transport-only: connection facts arrive through a thunk
+ * resolved once per operation and the optional bearer token through a
+ * per-request resolver, so the registering plugin owns validation, layering,
+ * and credential policy.
+ *
+ * @module dsh-lemonade-provider/adapter
+ */
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { CredentialRef } from '@deepseek-ai/dsh-credentials';
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmDiscoveredModel, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, ResolvedRetryPolicy, StreamChunk } from '@deepseek-ai/dsh-llm';
+/** Default endpoint (baseURL is the server root; /v1 paths are appended by each endpoint builder). */
+export declare const DEFAULT_BASE_URL = "http://localhost:13305";
+/** Default combined request/response context capacity for models with no metadata. */
+export declare const DEFAULT_CONTEXT_WINDOW = 32768;
+/** Default per-request output-token cap. */
+export declare const DEFAULT_MAX_TOKENS = 8192;
+/** Default maximum idle interval while an adapter stream read is outstanding. */
+export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS: number;
+/** Maximum time one live model-listing query may take. */
+export declare const LISTING_TIMEOUT_MS = 5000;
+/** One entry of the user-pinned advisory model catalog. */
+export interface LemonadeCatalogModel {
+    id: string;
+    name?: string;
+    description?: string;
+    contextWindow?: number;
+    maxTokens?: number;
+    vision?: boolean;
+}
+/** Validated connection facts resolved from raw config and the environment. */
+export interface LemonadeOptions {
+    apiKeyEnv: CredentialRef;
+    adminApiKeyEnv: CredentialRef;
+    baseURL: string;
+    requireAuth: boolean;
+    defaultContextWindow: number;
+    maxTokens: number;
+    models: LemonadeCatalogModel[];
+    streamIdleTimeoutMs: number;
+    retryPolicy: ResolvedRetryPolicy;
+}
+/** The adapter's dependency thunks, owned by the registering plugin. */
+export interface LemonadeAdapterConfig {
+    /** Current connection facts; re-resolved per operation, never cached across calls. */
+    options(): LemonadeOptions;
+    /** Current bearer token, or `undefined` when the endpoint is unauthenticated. */
+    resolveApiKey(): Promise<string | undefined>;
+    /** The attachment service, when one is mounted (needed to send images). */
+    resolveAttachments(): AttachmentStore | undefined;
+}
+/** One Lemonade model entry as read from `GET /v1/models`. */
+export interface LemonadeModelEntry {
+    id: string;
+    maxContextWindow?: number;
+    labels?: string[];
+    vision?: boolean;
+}
+/**
+ * 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 declare function fetchModelEntries(baseURL: string, apiKey: string | undefined, signal?: AbortSignal): Promise<LemonadeModelEntry[]>;
+/**
+ * Interrogate one Lemonade endpoint for the models it advertises, mapped to
+ * the harness discovery vocabulary (id + optional context window).
+ */
+export declare function discoverModels(baseURL: string, apiKey: string | undefined, signal?: AbortSignal): Promise<readonly LlmDiscoveredModel[]>;
+/**
+ * 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 declare class LemonadeAdapter extends LlmAdapter {
+    private readonly config;
+    /** The most recent successful live listing, keyed by model id (advisory cache, never authoritative). */
+    private lastKnown;
+    constructor(config: LemonadeAdapterConfig);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(_provider: string): ResolvedRetryPolicy | undefined;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncGenerator<StreamChunk>;
+    /** Build the image resolver from the mounted attachment service, if any. */
+    private resolveImage;
+    private request;
+}