@maci0/dsh-chatjimmy 0.11.4

package/lib/client.js

@@ -0,0 +1,398 @@
+/**
+ * dsh-chatjimmy: browser half.
+ *
+ * One surface: the ChatJimmy card on the Plugins page, keyed on the
+ * `chatjimmy` settings namespace the host half declares as its row id. Every
+ * field of the row that the host marks `volatile()` is editable here, and the
+ * adapter resolves the row per read, so a save lands on the next request
+ * without remounting the provider route.
+ *
+ * The form stages edits locally and writes them in one `scope.mutate` call:
+ * a half-typed base URL must not reach the settings document field by field.
+ * Chrome is a stylesheet, not inline style objects: the module system claims
+ * every `<style>` tag a factory appends while it materializes and removes it
+ * when the package unloads. Classes are `cj-`-prefixed because that sheet
+ * lands in the page's own document.
+ *
+ * This file is plain JavaScript on purpose. The client module system serves a
+ * package's `exports["./client"]` artifact as a lazy-CJS factory registered on
+ * `window.__ModuleLoader__`, and that is the whole format: an out-of-tree
+ * plugin can author it directly instead of reproducing the repository's tsdown
+ * client preset. `react` is provided by the module system; nothing else is
+ * required here.
+ */
+
+window.__ModuleLoader__.load({
+  id: '@maci0/dsh-chatjimmy',
+
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const React = require('react')
+
+    /** Settings namespace shared with the host half; also this card's slot key. */
+    const NAMESPACE = 'chatjimmy'
+
+    /** Locale namespace for this plugin's copy. */
+    const LOCALE_NS = 'chatjimmy'
+
+    /**
+     * Every editable row field, in display order. `integer` fields are sent as
+     * numbers and must be positive integers; the host schema bounds each one,
+     * and the card refuses what it can see before the write.
+     */
+    const FIELDS = [
+      { key: 'baseUrl', kind: 'text', label: 'labelBaseUrl', hint: 'hintBaseUrl' },
+      { key: 'model', kind: 'text', label: 'labelModel', hint: 'hintModel' },
+      { key: 'topK', kind: 'integer', label: 'labelTopK', hint: 'hintTopK' },
+      { key: 'contextWindow', kind: 'integer', label: 'labelContextWindow', hint: 'hintContextWindow' },
+      { key: 'streamIdleTimeoutMs', kind: 'integer', label: 'labelStreamIdleTimeoutMs', hint: 'hintStreamIdleTimeoutMs' },
+    ]
+
+    /** Every class is `cj-`-prefixed: the sheet lands in the page's own document. */
+    const CSS = [
+      '.cj-page{display:flex;flex-direction:column;gap:12px}',
+      '.cj-field{display:flex;flex-direction:column;gap:4px}',
+      '.cj-label{font-size:13px;font-weight:600;line-height:1.5;color:var(--dsw-alias-label-primary)}',
+      '.cj-hint{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-tertiary)}',
+      '.cj-input{font:inherit;font-size:13px;line-height:1.5;padding:5px 12px;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-4);border:1px solid var(--dsw-alias-border-l2);border-radius:8px;width:100%;box-sizing:border-box}',
+      '.cj-input:disabled{cursor:default;opacity:.5}',
+      '.cj-row{display:flex;flex-wrap:wrap;align-items:center;gap:8px}',
+      '.cj-button{appearance:none;font:inherit;font-size:13px;line-height:1.5;padding:5px 14px;cursor:pointer;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-4);border:1px solid var(--dsw-alias-border-l2);border-radius:8px}',
+      '.cj-button:disabled{cursor:default;opacity:.5}',
+      '.cj-button-quiet{padding:3px 10px;font-size:12px;color:var(--dsw-alias-label-secondary)}',
+      '.cj-status{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-tertiary)}',
+      '.cj-error{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-error)}',
+    ].join('')
+
+    // Appended while the factory materializes: the module system claims the tag
+    // for this package and disposes it on unload. Guarded because the node unit
+    // tests evaluate this file without a DOM.
+    if (typeof document !== 'undefined') {
+      const style = document.createElement('style')
+      style.textContent = CSS
+      document.head.append(style)
+    }
+
+    /** Plugin version, shown in the card footer. Kept in lockstep with package.json. */
+    const VERSION = '0.11.4'
+
+    const en = {
+      title: 'ChatJimmy',
+      summary: 'ChatJimmy text provider: model {model} at {baseUrl}.',
+      summaryEmpty: 'ChatJimmy text provider (not configured yet).',
+      description: 'ChatJimmy text provider: {model}',
+      labelBaseUrl: 'Base URL',
+      labelModel: 'Model',
+      labelTopK: 'topK',
+      labelContextWindow: 'Context window (tokens)',
+      labelStreamIdleTimeoutMs: 'Stream idle timeout (ms)',
+      hintBaseUrl: 'Deployment origin, no trailing slash needed.',
+      hintModel: 'Model id sent as chatOptions.selectedModel.',
+      hintTopK: 'Sampling breadth forwarded to the service. The site itself sends 8.',
+      hintContextWindow: 'Prompt + completion tokens; the service enforces 6144.',
+      hintStreamIdleTimeoutMs: 'A stream silent for this long ends with the TIMEOUT failure.',
+      overridden: 'overridden',
+      save: 'Save',
+      saving: 'Saving…',
+      saved: 'Saved. The next request uses these values.',
+      reset: 'Reset to defaults',
+      persists: 'Stored in your profile; the adapter reads the row on every request.',
+      readOnly: 'Read-only: this deployment does not persist settings.',
+      baseUrlInvalid: 'Base URL must be an absolute http(s) URL.',
+      modelInvalid: 'Model must be a non-empty id.',
+      numberInvalid: 'Must be a positive whole number.',
+      rejected: 'The Host refused the write; the previous values are still in effect.',
+      failed: 'Could not save: {message}',
+      version: 'v{version}',
+    }
+
+    const zh = {
+      title: 'ChatJimmy',
+      summary: 'ChatJimmy 文本提供方：模型 {model}，地址 {baseUrl}。',
+      summaryEmpty: 'ChatJimmy 文本提供方（尚未配置）。',
+      description: 'ChatJimmy 文本提供方：{model}',
+      labelBaseUrl: '基础地址',
+      labelModel: '模型',
+      labelTopK: 'topK',
+      labelContextWindow: '上下文窗口（token）',
+      labelStreamIdleTimeoutMs: '流空闲超时（毫秒）',
+      hintBaseUrl: '部署地址，结尾的斜杠可省略。',
+      hintModel: '作为 chatOptions.selectedModel 发送的模型 id。',
+      hintTopK: '转发给服务的采样广度。站点自身发送 8。',
+      hintContextWindow: '提示词与回复合计的 token 数；服务上限为 6144。',
+      hintStreamIdleTimeoutMs: '流在该时长内无输出即以 TIMEOUT 结束。',
+      overridden: '已覆盖',
+      save: '保存',
+      saving: '保存中…',
+      saved: '已保存。下一个请求将使用这些值。',
+      reset: '恢复默认',
+      persists: '保存在你的配置中；适配器每次请求都会读取该行。',
+      readOnly: '只读：此部署不持久化设置。',
+      baseUrlInvalid: '基础地址必须是绝对的 http(s) URL。',
+      modelInvalid: '模型必须是非空 id。',
+      numberInvalid: '必须是正整数。',
+      rejected: 'Host 拒绝了写入；原先的值仍然有效。',
+      failed: '保存失败：{message}',
+      version: 'v{version}',
+    }
+
+    /**
+     * Bind one settings scope to a React subscription.
+     * @param scope - the scope bound to the chatjimmy settings namespace.
+     * @returns a hook reading that scope's current snapshot.
+     */
+    function useScope(scope) {
+      const subscribe = (listener) => scope.subscribe(listener)
+      const getSnapshot = () => scope.getSnapshot()
+      return () => React.useSyncExternalStore(subscribe, getSnapshot)
+    }
+
+    /**
+     * Read a snapshot's resolved row. A namespace this deployment does not
+     * serve reports no row, which the card renders as nothing at all.
+     * @param snapshot - the settings scope snapshot.
+     * @returns the resolved row, or `undefined` when unreadable.
+     */
+    function rowOf(snapshot) {
+      if (snapshot.status !== 'ready') return undefined
+      return snapshot.value !== null && typeof snapshot.value === 'object' ? snapshot.value : {}
+    }
+
+    /** One editable field: label, hint, input, and the override marker. */
+    function Field(props) {
+      const { t, field, value, overridden, disabled, onChange } = props
+      return React.createElement(
+        'div',
+        { className: 'cj-field' },
+        React.createElement(
+          'div',
+          { className: 'cj-row' },
+          React.createElement('span', { className: 'cj-label' }, t(field.label)),
+          overridden === true
+            ? React.createElement('span', { className: 'cj-hint' }, `(${t('overridden')})`)
+            : null,
+        ),
+        React.createElement('input', {
+          className: 'cj-input',
+          type: field.kind === 'integer' ? 'number' : 'text',
+          value: value,
+          disabled,
+          'aria-label': t(field.label),
+          onChange: (event) => { onChange(field.key, event.target.value) },
+        }),
+        React.createElement('span', { className: 'cj-hint' }, t(field.hint)),
+      )
+    }
+
+    /**
+     * Build the card component over one bound settings scope.
+     * @param scope - the scope bound to the chatjimmy settings namespace.
+     * @param t - translate function bound to this plugin's locale namespace.
+     * @returns the component the slot renders.
+     */
+    function createCard(scope, t) {
+      const useChatJimmy = useScope(scope)
+
+      return function ChatJimmyCard(props) {
+        const snapshot = useChatJimmy()
+        const [draft, setDraft] = React.useState(null)
+        const [error, setError] = React.useState(null)
+        const [status, setStatus] = React.useState(null)
+        const [pending, setPending] = React.useState(false)
+
+        const row = rowOf(snapshot)
+        // A namespace this deployment does not serve renders no trace of itself.
+        if (row === undefined) return null
+
+        if (props != null && props.view === 'summary') {
+          return row.model === undefined
+            ? t('summaryEmpty')
+            : t('summary', { model: String(row.model), baseUrl: String(row.baseUrl) })
+        }
+
+        const disabled = !snapshot.writable || pending
+        const shown = draft ?? row
+        const user = snapshot.user !== null && typeof snapshot.user === 'object' ? snapshot.user : {}
+
+        /**
+         * Validate and collect the staged edits.
+         * @returns an error key, or the ordered path operations to write.
+         */
+        const collect = () => {
+          const ops = []
+          for (const field of FIELDS) {
+            const value = shown[field.key]
+            const original = row[field.key]
+            if (String(value) === String(original)) continue
+            if (field.kind === 'integer') {
+              const parsed = Number(value)
+              if (!Number.isInteger(parsed) || parsed <= 0) return { error: 'numberInvalid' }
+              ops.push({ op: 'set', path: [field.key], value: parsed })
+              continue
+            }
+            const text = String(value).trim()
+            if (field.key === 'model') {
+              if (text === '') return { error: 'modelInvalid' }
+              ops.push({ op: 'set', path: [field.key], value: text })
+              continue
+            }
+            if (text === '') return { error: 'baseUrlInvalid' }
+            // A scheme prefix is not a URL: the host resolver parses with
+            // `new URL` and refuses a root carrying credentials, a query, or a
+            // fragment, so the card rejects exactly what that throws on.
+            let parsedUrl
+            try {
+              parsedUrl = new URL(text)
+            } catch {
+              return { error: 'baseUrlInvalid' }
+            }
+            if (parsedUrl.protocol !== 'https:' && parsedUrl.protocol !== 'http:') {
+              return { error: 'baseUrlInvalid' }
+            }
+            // `resolveConfig` refuses the same four cases: the adapter appends
+            // `/api/chat` to this root, so credentials (which `fetch` rejects
+            // outright), a query, or a fragment can never address the endpoint.
+            if (parsedUrl.username.length > 0 || parsedUrl.password.length > 0
+              || parsedUrl.search.length > 0 || parsedUrl.hash.length > 0) {
+              return { error: 'baseUrlInvalid' }
+            }
+            ops.push({ op: 'set', path: [field.key], value: text })
+          }
+          return { ops }
+        }
+
+        const write = (ops) => new Promise((resolve) => { resolve(scope.mutate(ops)) })
+
+        const save = () => {
+          if (disabled) return
+          setError(null)
+          const result = collect()
+          if (result.error !== undefined) {
+            setError(t(result.error))
+            return
+          }
+          if (result.ops.length === 0) {
+            // Nothing moved: an edit that landed back on the stored value is
+            // not a change, and the row already holds it.
+            setStatus(null)
+            return
+          }
+          setStatus(t('saving'))
+          setPending(true)
+          write(result.ops)
+            .then((accepted) => {
+              if (accepted === false) {
+                setError(t('rejected'))
+                setStatus(null)
+                return
+              }
+              setDraft(null)
+              setStatus(t('saved'))
+            })
+            .catch((cause) => {
+              setStatus(null)
+              setError(t('failed', { message: cause instanceof Error ? cause.message : String(cause) }))
+            })
+            .finally(() => { setPending(false) })
+        }
+
+        const reset = () => {
+          if (disabled) return
+          setDraft(null)
+          setStatus(null)
+          setError(null)
+          const ops = Object.keys(user)
+            .filter((key) => FIELDS.some((field) => field.key === key))
+            .map((key) => ({ op: 'unset', path: [key] }))
+          if (ops.length === 0) return
+          setPending(true)
+          write(ops)
+            .then((accepted) => {
+              // A refused reset is as visible as a refused save: silence here
+              // reads as "reset worked" while the override is still in effect.
+              if (accepted === false) setError(t('rejected'))
+            })
+            .catch((cause) => {
+              setError(t('failed', { message: cause instanceof Error ? cause.message : String(cause) }))
+            })
+            .finally(() => { setPending(false) })
+        }
+
+        const overridden = Object.keys(user).some((key) => FIELDS.some((field) => field.key === key))
+
+        return React.createElement(
+          'div',
+          { className: 'cj-page' },
+          ...FIELDS.map((field) => React.createElement(Field, {
+            key: field.key,
+            t,
+            field,
+            value: String(shown[field.key] ?? ''),
+            overridden: Object.hasOwn(user, field.key),
+            disabled,
+            onChange: (key, value) => {
+              setStatus(null)
+              setDraft({ ...shown, [key]: value })
+            },
+          })),
+          React.createElement(
+            'div',
+            { className: 'cj-row' },
+            React.createElement(
+              'button',
+              { type: 'button', className: 'cj-button', disabled, onClick: save },
+              t('save'),
+            ),
+            overridden
+              ? React.createElement(
+                'button',
+                { type: 'button', className: 'cj-button cj-button-quiet', disabled, onClick: reset },
+                t('reset'),
+              )
+              : null,
+          ),
+          React.createElement(
+            'div',
+            { className: 'cj-status' },
+            status ?? (snapshot.writable ? t('persists') : t('readOnly')),
+            ' ',
+            t('version', { version: VERSION }),
+          ),
+          error === null ? null : React.createElement('div', { className: 'cj-error' }, error),
+        )
+      }
+    }
+
+    /**
+     * Mount the browser surface: the ChatJimmy card on the Plugins page.
+     * @param ctx - the browser plugin context.
+     */
+    function apply(ctx) {
+      const t = ctx.locale.bind(LOCALE_NS)
+      ctx.effect(
+        () => ctx.locale.register(LOCALE_NS, { en, zh }),
+        'dsh-chatjimmy: locale dictionary',
+      )
+
+      const scope = ctx.configForms.get(NAMESPACE)
+      const Card = createCard(scope, t)
+
+      // The owner declares its own slot; injecting waits for it to exist, so
+      // this registration does not depend on plugin load order. The card takes
+      // no injected props (it closes over its own bound scope), so the entry
+      // declares the documented `locale` namespace and no `inject`.
+      ctx.slots.inject('plugins.row.config', () => ctx.slots.register({
+        name: 'plugins.row.config',
+        key: '@maci0/dsh-chatjimmy#chatjimmy',
+        locale: LOCALE_NS,
+      }, Card))
+    }
+
+    exports.apply = apply
+    exports.inject = ['slots', 'configForms', 'locale']
+    return module.exports
+  },
+})

package/lib/host.js

@@ -0,0 +1,21 @@
+/**
+ * The slice of the DeepSeek Harness host surface this plugin uses, declared
+ * structurally.
+ *
+ * Like the other plugins under `~/dsh-plugins`, this package declares the host
+ * surface it consumes rather than depending on the harness's own classes: its
+ * one runtime `@deepseek-ai/*` dependency is `@deepseek-ai/dsh-llm`'s pure
+ * `attributionHeaders()` / `resolveRetryPolicy()` helpers. The harness reaches
+ * its adapters through plain method calls on the registered object (there is
+ * no `instanceof LlmAdapter` check anywhere in `LlmRuntime`), so a duck-typed
+ * adapter is a supported shape, not a workaround.
+ *
+ * Each declaration here is deliberately narrowed to what this adapter reads or
+ * emits. Mirroring a foreign API in full is not documentation: a field we never
+ * touch is a field whose absence goes unnoticed, which is how the missing
+ * `providerRetryPolicy` reached an integration test instead of a compiler.
+ * Widen a declaration when the adapter starts using it, not before.
+ *
+ * @module dsh-chatjimmy/host
+ */
+export {};

package/lib/index.js

@@ -0,0 +1,172 @@
+/**
+ * dsh-chatjimmy: use the chatjimmy.ai model inside DeepSeek Harness.
+ *
+ * One capability: an `ctx.llm` provider adapter for the reconstructed chat API
+ * (see `API.md`). Registering it makes the route selectable in the Web client's
+ * model picker, because `buildModelCatalog()` enumerates `ctx.llm.listProviders()`
+ * and asks each adapter for `listModels()` / `resolveModel()`.
+ *
+ * See README.md for the known limits: the service has no tool-calling, no
+ * image input, and a 6144-token total context.
+ *
+ * @module dsh-chatjimmy
+ */
+import Schema from '@deepseek-ai/schemastery';
+import { RetryPolicySchema } from '@deepseek-ai/dsh-llm';
+import { ChatJimmyAdapter } from './adapter.js';
+/** Plugin name as it appears in the loader. */
+export const name = 'chatjimmy';
+/** The `ctx.llm` provider route this adapter owns. */
+export const PROVIDER = 'chatjimmy';
+/** The one service this plugin needs mounted. */
+export const inject = ['llm'];
+/**
+ * Total context the backend enforces, in tokens, measured empirically:
+ * a request whose reported `prefill_tokens` reached 6141 with 2 output tokens
+ * succeeded, while one needing 6143 + 2 returned a zero-byte body. The site's
+ * own client caps at the same number (`NEXT_PUBLIC_TOKEN_LIMIT`, default 6144).
+ */
+const CONTEXT_WINDOW = 6144;
+/** Model the service serves. `/api/models` advertises exactly this one id. */
+const DEFAULT_MODEL = 'llama3.1-8B';
+/** Base URL of the deployment. */
+const DEFAULT_BASE_URL = 'https://chatjimmy.ai';
+/** Per-read stream idle watchdog default, matching the shipped remote adapters. */
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300_000;
+/** `setTimeout`'s maximum delay; a larger configured timeout is rejected at load. */
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+/**
+ * Field defaults and bounds with no volatility wrapper.
+ *
+ * {@link resolveConfig} parses a plain row through this schema, so its output
+ * is plain values; the loader-facing {@link Config} below is the same shape
+ * with every editable field made `volatile()`, which is what hands the plugin
+ * a live reference. The pair is asserted equal in the suite.
+ */
+const ValueSchema = Schema.object({
+    baseUrl: Schema.string().default(DEFAULT_BASE_URL),
+    model: Schema.string().default(DEFAULT_MODEL),
+    topK: Schema.number().step(1).min(1).default(8),
+    contextWindow: Schema.number().step(1).min(1).default(CONTEXT_WINDOW),
+    streamIdleTimeoutMs: Schema.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS)
+        .default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+    retryPolicy: RetryPolicySchema,
+});
+/**
+ * Row schema as Cordis resolves it: defaults live here, so a deployment only
+ * states what it changes.
+ *
+ * Every field a user may edit is `volatile()`: the settings document accepts
+ * only volatile paths, and the browser half's card edits exactly these. The
+ * adapter resolves the row per read, so an edit lands on the next request
+ * instead of waiting for a remount. `retryPolicy` stays ordinary
+ * configuration: patch-only, as its docs say.
+ */
+export const Config = Schema.object({
+    baseUrl: Schema.string().default(DEFAULT_BASE_URL).volatile(),
+    model: Schema.string().default(DEFAULT_MODEL).volatile(),
+    topK: Schema.number().step(1).min(1).default(8).volatile(),
+    contextWindow: Schema.number().step(1).min(1).default(CONTEXT_WINDOW).volatile(),
+    streamIdleTimeoutMs: Schema.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS)
+        .default(DEFAULT_STREAM_IDLE_TIMEOUT_MS).volatile(),
+    retryPolicy: RetryPolicySchema,
+});
+/**
+ * Validate and normalize one configuration row.
+ *
+ * The row is fed back through the exported `Config` schema, which is the one
+ * source of the defaults and the numeric bounds. Cordis already ran the same
+ * schema before `apply`, so this only makes `resolveConfig` usable on its own.
+ * What the schema cannot express is checked here: invalid values throw rather
+ * than being silently defaulted, because a typo'd base URL would otherwise
+ * present as an opaque transport failure on the first message.
+ *
+ * @param config - raw row configuration.
+ * @returns the resolved adapter configuration.
+ */
+export function resolveConfig(config = {}) {
+    const resolved = ValueSchema(config);
+    const baseUrl = resolved.baseUrl.replace(/\/+$/, '');
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        throw new Error(`chatjimmy: baseUrl "${resolved.baseUrl}" is not a valid absolute URL`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new Error(`chatjimmy: baseUrl "${resolved.baseUrl}" must use http or https`);
+    }
+    // The adapter appends `/api/chat` to this root. Credentials make `fetch`
+    // refuse the URL (and hide the real host behind a look-alike userinfo), and a
+    // query or fragment swallows the appended path, so no such URL can ever
+    // address the documented endpoint. Same rule as the harness's own providers.
+    if (parsed.username.length > 0 || parsed.password.length > 0 || parsed.search.length > 0 || parsed.hash.length > 0) {
+        throw new Error(`chatjimmy: baseUrl "${resolved.baseUrl}" must be an HTTP(S) root without credentials, query, or fragment`);
+    }
+    // Any string is a valid model id to the schema, but the empty one is not a model.
+    if (resolved.model.trim().length === 0)
+        throw new Error('chatjimmy: model must be a non-empty string');
+    // `min`/`max` cannot see NaN (every comparison against it is false, so NaN
+    // passes both), and schemastery has no refinement hook. One explicit check.
+    for (const field of ['topK', 'contextWindow', 'streamIdleTimeoutMs']) {
+        if (!Number.isFinite(resolved[field])) {
+            throw new Error(`chatjimmy: ${field} must be a finite number, got ${String(resolved[field])}`);
+        }
+    }
+    return { ...resolved, baseUrl };
+}
+/**
+ * Read the live row out of the references the loader resolved.
+ *
+ * Every editable field arrives as a `Volatile<T>`; this is the one place that
+ * turns them back into the plain values the schema and the adapter understand,
+ * so a caller cannot forget one.
+ *
+ * @param config - the resolved row.
+ * @returns plain row values, with absent references left undefined.
+ */
+export function liveOptions(config) {
+    return {
+        baseUrl: config.baseUrl.get(),
+        model: config.model.get(),
+        topK: config.topK.get(),
+        contextWindow: config.contextWindow.get(),
+        streamIdleTimeoutMs: config.streamIdleTimeoutMs.get(),
+        retryPolicy: config.retryPolicy,
+    };
+}
+/**
+ * Mount the adapter.
+ *
+ * The adapter is handed the resolver itself, not one resolved row: every
+ * configurable field is `volatile()`, so a settings write from the Plugins
+ * card changes what the next request uses without remounting the provider
+ * route (which would drop the model picker's selection). The row is resolved
+ * once here anyway, so an unusable one still fails at mount the way a
+ * non-volatile row would.
+ *
+ * @param ctx - host context; `ctx.llm` must be mounted (`inject` guarantees it).
+ * @param config - this plugin's row configuration.
+ */
+export function apply(ctx, config) {
+    const live = () => resolveConfig(liveOptions(config));
+    const resolved = live();
+    ctx.llm.registerAdapter([PROVIDER], new ChatJimmyAdapter(live));
+    ctx.logger.info(`chatjimmy: provider "${PROVIDER}" registered for model "${resolved.model}" at ${resolved.baseUrl}`
+        + ` (text only, ${resolved.contextWindow}-token total context)`);
+    // Report edits rather than swallowing them: a card write that made the row
+    // unusable has to be visible somewhere, and this is the only surface the
+    // host owns. The value stays on the row, so the request that needs it will
+    // raise the same error with the same message.
+    ctx.on('loader/volatile-update', () => {
+        try {
+            const next = live();
+            ctx.logger.info(`chatjimmy: configuration updated: model "${next.model}" at ${next.baseUrl}`
+                + `, topK ${String(next.topK)}, ${next.contextWindow}-token context`);
+        }
+        catch (error) {
+            ctx.logger.warn(`chatjimmy: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}