@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/plugins/computer-use/index.mjs

@@ -0,0 +1,37 @@
+/**
+ * Computer Use, mounted through DSCODE so a retired settings API still resolves.
+ *
+ * `@anionex/dsh-computer-use` reads its configuration with `ctx.settings.register`, an API
+ * DSH removed in 0.1.7: Settings now projects forms from the profile entry itself, and the
+ * missing method made the whole Computer Use bundle fail to activate. The package is
+ * pinned at 0.3.2 with no newer release, so this row restores the method — as a read-only
+ * view over the composition config, which is where DSCODE configures Computer Use anyway —
+ * and then mounts the upstream bundle as its child, which is what makes the order
+ * dependable: the shim is installed before the provider's constructor runs.
+ *
+ * Retire this wrapper when the package reads volatile configuration, and mount
+ * `@anionex/dsh-computer-use` directly again.
+ *
+ * @module dscode-computer-use
+ */
+
+import ComputerUseBundle from '@anionex/dsh-computer-use';
+
+export const name = 'dscode-computer-use';
+export const inject = ['settings'];
+
+/** Section handle the 0.3.x provider expects: one read of the composition config, no live writes. */
+function staticSection(base) {
+  return { get: () => base, watch: () => () => {} };
+}
+
+export function apply(ctx, config = {}) {
+  const settings = ctx.settings;
+  // Only ever adds what upstream no longer defines; a Settings service that carries its
+  // own `register` again is left untouched, and the shim is dropped with this row.
+  if (typeof settings.register !== 'function') {
+    settings.register = (_namespace, _schema, options = {}) => staticSection(options.base ?? {});
+    ctx.effect(() => () => { delete settings.register; });
+  }
+  ctx.plugin(ComputerUseBundle, config);
+}

package/plugins/cordis-config/plain.mjs

@@ -0,0 +1,31 @@
+/**
+ * One plain snapshot of a Cordis plugin configuration.
+ *
+ * Two shapes make a foreign entry's `config` unusable as a plain object. DSH 0.1.7 hands
+ * a `.volatile()` field to its own plugin as a reference rather than a value, and the
+ * Loader keeps a YAML `!!js` scalar as an unevaluated `{ __jsExpr }` node until the entry
+ * activates — which a reader inspecting another entry's row (the skills conflict report
+ * walks every `skill-filesystem` entry, and a preset's rows carry such expressions) sees
+ * instead of the value. References are read; an expression cannot be evaluated outside the
+ * Loader's own scope, so it reads as absent and the caller applies its own fallback.
+ *
+ * @param config - a configuration object whose fields may be references or expressions.
+ * @returns a shallow copy carrying only plainly readable values.
+ */
+export function plainConfig(config) {
+  if (config === null || typeof config !== 'object') return {};
+  const entries = Object.entries(config)
+    .map(([key, value]) => [key, isReference(value) ? value.get() : value])
+    .filter(([, value]) => !isExpression(value));
+  return Object.fromEntries(entries);
+}
+
+/** Whether a configuration field is a Cordis value reference rather than a plain value. */
+function isReference(value) {
+  return value !== null && typeof value === 'object' && typeof value.get === 'function';
+}
+
+/** Whether a configuration field is still an unevaluated Loader expression node. */
+function isExpression(value) {
+  return value !== null && typeof value === 'object' && '__jsExpr' in value;
+}

package/plugins/credentials/index.mjs

@@ -0,0 +1,73 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { LocalCredentialProvider } from '@deepseek-ai/dsh-credentials-local';
+import { Context, Service } from '@deepseek-ai/cordis';
+import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
+import { isCustomKey } from '../custom/config.mjs';
+import { PROVIDERS } from '../providers/catalog.mjs';
+import { GROK_TOKEN_REF, grokAuthState } from '../grok/auth.mjs';
+
+// The `/provider` credentials (DeepSeek, OpenRouter and its management key, the OpenCode Go
+// login) live in the shared store.
+const SHARED = new Set(PROVIDERS.flatMap(provider => [provider.credentialRef, provider.managementRef].filter(Boolean)));
+// Credentials a login command writes (the OpenCode Go account login): described as read-only
+// so no key form is offered, while the owning plugin still stores them through `set`.
+const LOGINS = new Set(PROVIDERS.filter(provider => provider.login).map(provider => provider.credentialRef));
+
+// Use the native locked, watched, owner-only store. Keep this independent of
+// the installed profile so upgrades and different projects share credentials.
+export default class DscodeCredentials extends LocalCredentialProvider {
+  shared;
+  sharedConfig;
+  constructor(ctx, config = {}) {
+    // Retain the old profile store, including other providers and OAuth records.
+    super(ctx, { ...config, path: undefined });
+    this.sharedConfig = { ...config, path: config.path ?? join(homedir(), '.dscode', 'credentials.yaml') };
+  }
+  async *[Service.init]() {
+    const sharedContext = new Context();
+    yield () => sharedContext.fiber.dispose();
+    sharedContext.provide('launchEnvironment', launchEnvironmentOf(this.ctx));
+    sharedContext.on('credentials/reference-updated', ref => this.notifyUpdated(ref));
+    await sharedContext.plugin(LocalCredentialProvider, this.sharedConfig);
+    this.shared = sharedContext.credentials;
+    yield* super[Service.init]();
+  }
+  async resolve(ref) {
+    // dscode: the Grok subscription rail is the official CLI login, read-only. DSCODE never
+    // writes that file: the CLI owns refresh-token rotation, and two writers log the other out.
+    if (ref === GROK_TOKEN_REF) {
+      const state = grokAuthState();
+      return state.kind === 'ready' ? { value: state.credential.token, source: 'file' } : undefined;
+    }
+    if (SHARED.has(ref) || isCustomKey(ref)) {
+      const stored = await this.shared.resolve(ref);
+      if (stored?.source === 'env' || stored?.source === 'file') return stored;
+    }
+    return super.resolve(ref);
+  }
+  async describe(ref) {
+    if (ref === GROK_TOKEN_REF) {
+      const state = grokAuthState();
+      return state.kind === 'ready' ? { configured: true, source: 'file', writable: false } : { configured: false, writable: false };
+    }
+    if (LOGINS.has(ref)) {
+      return (await this.shared.resolve(ref))?.value ? { configured: true, source: 'account', writable: false } : { configured: false, writable: false };
+    }
+    if (SHARED.has(ref) || isCustomKey(ref)) {
+      const facts = await this.shared.describe(ref);
+      if (facts.source === 'env' || facts.source === 'file') return facts;
+    }
+    return super.describe(ref);
+  }
+  set(ref, value) {
+    // The CLI file is not a DSCODE store: saving here would go somewhere nothing reads.
+    if (ref === GROK_TOKEN_REF) throw new Error('GROK_CLI_TOKEN comes from ~/.grok/auth.json; run grok login instead');
+    return (SHARED.has(ref) || isCustomKey(ref)) ? this.shared.set(ref, value) : super.set(ref, value);
+  }
+  async unset(ref) {
+    // Explicit removal must not uncover a previously configured legacy key.
+    if (SHARED.has(ref) || isCustomKey(ref)) await this.shared.unset(ref);
+    await super.unset(ref);
+  }
+}

package/plugins/custom/adapter.mjs

@@ -0,0 +1,110 @@
+import { LlmAdapter, LlmError, ReasoningEffortId, attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { isAttachmentError } from '@deepseek-ai/dsh-attachment';
+import { sseData, translate } from '../providers/chat-stream.mjs';
+import { errorCode, retryAfterMs } from '../providers/http-errors.mjs';
+import { endpoint } from './config.mjs';
+import { normalizedEvents, requestBody, REPLAY_KIND } from './wire.mjs';
+import { prepareImages } from './images.mjs';
+
+export function authHeaders(profile, key) {
+  if (profile.auth !== 'none' && !key) throw new LlmError('Custom provider needs an API key; edit it in /provider → Custom', 'MISSING_CREDENTIAL');
+  return { ...(profile.api === 'anthropic' ? { 'anthropic-version': '2023-06-01' } : {}),
+    ...(profile.auth === 'none' ? {} : profile.auth === 'x-api-key' ? { 'x-api-key': key } : { authorization: `Bearer ${key}` }) };
+}
+
+/** One request per service in this Host. Background calls queue behind foreground work. */
+class RequestQueue {
+  busy = false;
+  waiting = [];
+  async acquire(signal, background) {
+    signal?.throwIfAborted();
+    if (!this.busy) { this.busy = true; return () => this.release(); }
+    await new Promise((resolve, reject) => {
+      const item = { resolve, background };
+      const abort = () => { this.waiting = this.waiting.filter(x => x !== item); reject(signal.reason); };
+      item.resolve = () => { signal?.removeEventListener('abort', abort); resolve(); };
+      signal?.addEventListener('abort', abort, { once: true });
+      this.waiting.push(item);
+    });
+    return () => this.release();
+  }
+  release() {
+    if (!this.waiting.length) { this.busy = false; return; }
+    const foreground = this.waiting.findIndex(x => !x.background);
+    this.waiting.splice(foreground < 0 ? 0 : foreground, 1)[0].resolve();
+  }
+}
+
+export class CustomAdapter extends LlmAdapter {
+  constructor({ profile, resolveKey, resolveAttachments, resolveImageAccess, fetch = globalThis.fetch }) {
+    super(); this.profile = profile; this.resolveKey = resolveKey; this.fetch = fetch; this.queues = new Map();
+    this.resolveAttachments = resolveAttachments; this.resolveImageAccess = resolveImageAccess;
+  }
+  providerInfo(provider) { return { id: provider, name: this.profile(provider)?.name ?? provider }; }
+  async listModels(provider) {
+    return (this.profile(provider)?.models ?? []).filter(m => m.contextWindow).map(m => ({ provider, id: m.id, name: m.name, inputModalities: [...(m.inputModalities ?? ['text'])] }));
+  }
+  async resolveModel(provider, id) {
+    const p = this.profile(provider), m = p?.models.find(m => m.id === id);
+    if (!m?.contextWindow) throw new LlmError('Custom model is missing or has no context window; edit it in /provider → Custom', 'INVALID_REQUEST');
+    return { provider, id, name: m.name, inputModalities: [...(m.inputModalities ?? ['text'])], context: { contextWindow: m.contextWindow },
+      defaultMaxTokens: m.maxTokens ?? Math.min(4096, Math.floor(m.contextWindow / 4)),
+      ...(p.backend === 'omlx' ? { reasoning: { efforts: [{ id: ReasoningEffortId('off'), name: 'Off' }, { id: ReasoningEffortId('high'), name: 'On' }], ...(m.thinking !== 'default' ? { defaultEffort: ReasoningEffortId(m.thinking === 'off' ? 'off' : 'high') } : {}) } } : {}) };
+  }
+  async *stream(options) {
+    const profile = this.profile(options.provider);
+    const model = profile?.models.find(m => m.id === options.model);
+    if (!model?.contextWindow) throw new LlmError('Configure this custom model and its context window first', 'INVALID_REQUEST');
+    const controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, ...(options.signal ? [options.signal] : [])]);
+    let timer, release, timedOut = false;
+    const pulse = () => { clearTimeout(timer); timer = setTimeout(() => { timedOut = true; controller.abort(); }, profile.timeoutMs); timer.unref?.(); };
+    try {
+      let queue = this.queues.get(profile.id);
+      if (!queue) { queue = new RequestQueue(); this.queues.set(profile.id, queue); }
+      release = await queue.acquire(signal, ['session-title', 'session-card', 'compaction'].includes(options.purpose));
+      signal.throwIfAborted();
+      const key = await this.resolveKey(profile);
+      const attachments = this.resolveAttachments?.();
+      const images = await prepareImages(options.messages, model, attachments, ref => attachments && this.resolveImageAccess?.(attachments, ref), signal);
+      signal.throwIfAborted();
+      const body = requestBody(profile, model, { ...options, messages: images.messages }, images);
+      pulse();
+      const response = await this.fetch(endpoint(profile), { method: 'POST', redirect: 'error', headers: { ...attributionHeaders(), ...authHeaders(profile, key), 'content-type': 'application/json', accept: 'text/event-stream' }, body: JSON.stringify(body), signal });
+      if (!response.ok) {
+        // Inspect the error only to classify context overflow/rate limits. Never
+        // attach the raw response: gateways sometimes echo their request headers.
+        const raw = await response.text();
+        let detail;
+        try { detail = JSON.parse(raw)?.error; } catch { /* status still classifies non-JSON errors */ }
+        const delay = retryAfterMs(response.headers.get('retry-after'));
+        throw new LlmError(`Custom API returned HTTP ${response.status}`, errorCode(response.status, detail), { status: response.status, ...(delay ? { providerRetryAfterMs: delay } : {}) });
+      }
+      if (!response.body || !response.headers.get('content-type')?.includes('text/event-stream')) {
+        await response.body?.cancel();
+        throw new LlmError('Custom API did not return an SSE stream', 'MALFORMED_RESPONSE');
+      }
+      const replay = {};
+      const events = normalizedEvents(sseData(response.body, pulse), profile.api, replay);
+      for await (const chunk of translate(events, { model: model.id, kind: REPLAY_KIND, label: profile.name })) {
+        if (chunk.type === 'block-end' && chunk.block.type === 'tool-call') {
+          try { const args = JSON.parse(chunk.block.arguments); if (!args || typeof args !== 'object' || Array.isArray(args) || !chunk.block.id || !chunk.block.name) throw Error(); }
+          catch { throw new LlmError('Custom model returned an invalid tool call', 'MALFORMED_RESPONSE'); }
+        }
+        if (chunk.type === 'finish' && chunk.replayState) Object.assign(chunk.replayState.response, { api: profile.api, ...replay });
+        clearTimeout(timer); yield chunk; pulse();
+      }
+    } catch (error) {
+      if (options.signal?.aborted) throw new LlmError('Custom request cancelled', 'ABORTED');
+      if (timedOut) throw new LlmError(`Custom API idle timeout after ${profile.timeoutMs}ms; the model may still be loading`, 'TIMEOUT');
+      if (isAttachmentError(error)) throw new LlmError(`Custom image input failed: ${error.code}`, error.code);
+      // Never reflect a server response or transport error that might contain credentials.
+      if (error instanceof LlmError) throw new LlmError(error.code === 'MISSING_CREDENTIAL' ? error.message : `Custom request failed: ${error.code}`, error.code, {
+        ...(error.failure?.status ? { status: error.failure.status } : {}),
+        ...(error.failure?.providerRetryAfterMs ? { providerRetryAfterMs: error.failure.providerRetryAfterMs } : {}),
+        ...(error.failure?.offloadImages ? { offloadImages: error.failure.offloadImages } : {}),
+      });
+      throw new LlmError('Could not connect to the custom API', 'TRANSPORT');
+    } finally { clearTimeout(timer); controller.abort(); release?.(); }
+  }
+}

package/plugins/custom/config.mjs

@@ -0,0 +1,85 @@
+import { randomUUID, createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { parse, stringify } from 'yaml';
+
+export const PROTOCOLS = ['chat-completions', 'responses', 'anthropic'];
+export const customId = () => `custom-${randomUUID()}`;
+export const isCustomId = id => typeof id === 'string' && /^custom-[a-zA-Z0-9-]+$/.test(id);
+export const keyRef = id => `DSCODE_CUSTOM_${id.replaceAll('-', '_').toUpperCase()}_API_KEY`;
+export const isCustomKey = ref => /^DSCODE_CUSTOM_CUSTOM_[A-Z0-9_]+_API_KEY$/.test(ref);
+const positive = value => Number.isSafeInteger(value) && value > 0;
+const cleanText = value => typeof value === 'string' && value.trim() && !/[\x00-\x1f\x7f]/.test(value);
+
+export function endpoint(profile) {
+  return profile.baseURL + ({ 'chat-completions': '/chat/completions', responses: '/responses', anthropic: '/messages' })[profile.api];
+}
+
+/** Validate persisted data and drafts with the same rules; never persist a key. */
+export function validateProfile(input) {
+  if (!isCustomId(input?.id)) throw Error('Invalid custom provider ID');
+  if (!cleanText(input.name)) throw Error('Enter a provider name');
+  let url;
+  try { url = new URL(input.baseURL); } catch { throw Error('Enter an HTTP or HTTPS API base URL'); }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw Error('Base URL must use HTTP(S), without credentials, query or fragment');
+  if (!PROTOCOLS.includes(input.api)) throw Error('Choose a supported API format');
+  if (!['none', 'bearer', 'x-api-key'].includes(input.auth)) throw Error('Choose an authentication method');
+  const models = (input.models ?? []).map(model => {
+    if (!cleanText(model.id)) throw Error('Enter a model ID');
+    for (const field of ['contextWindow', 'maxTokens']) if (model[field] !== undefined && !positive(model[field])) throw Error(`${field} must be a positive integer`);
+    if (model.maxTokens && model.contextWindow && model.maxTokens >= model.contextWindow) throw Error('Output budget must be smaller than the context window');
+    if (!['default', 'off', 'on'].includes(model.thinking ?? 'default')) throw Error('Invalid thinking setting');
+    const inputModalities = model.inputModalities ?? ['text'];
+    if (!Array.isArray(inputModalities) || !inputModalities.includes('text') || inputModalities.some(m => !['text', 'image'].includes(m)) || new Set(inputModalities).size !== inputModalities.length) throw Error('Model input must be text or text and image');
+    return {
+      id: model.id.trim(), name: cleanText(model.name) ? model.name.trim() : model.id.trim(),
+      ...(model.contextWindow ? { contextWindow: model.contextWindow, contextSource: model.contextSource === 'server' ? 'server' : 'user' } : {}),
+      // A deliberately blank output budget selects the calculated default and
+      // remains a user override when the service is discovered again.
+      ...(model.maxTokens ? { maxTokens: model.maxTokens, outputSource: model.outputSource === 'server' ? 'server' : 'user' }
+        : model.outputSource === 'user' ? { outputSource: 'user' } : {}),
+      thinking: model.thinking ?? 'default',
+      inputModalities: inputModalities.includes('image') ? ['text', 'image'] : ['text'],
+    };
+  });
+  if (new Set(models.map(m => m.id)).size !== models.length) throw Error('Model IDs must be unique within a provider');
+  const timeoutMs = input.timeoutMs ?? 180000;
+  if (!positive(timeoutMs)) throw Error('Request idle timeout must be positive');
+  return { id: input.id, name: input.name.trim(), baseURL: url.href.replace(/\/+$/, ''), api: input.api, auth: input.auth,
+    backend: input.backend === 'omlx' ? 'omlx' : 'generic', timeoutMs, models };
+}
+
+/** Whole-file revision + cross-process lock: stale editors never overwrite another Host. */
+export class CustomStore {
+  constructor(path = join(homedir(), '.dscode', 'providers.yaml')) { this.path = path; }
+  async read() {
+    let raw;
+    try { raw = await readFile(this.path, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; raw = ''; }
+    const doc = raw ? parse(raw) : { version: 1, providers: [] };
+    if (doc?.version !== 1 || !Array.isArray(doc.providers)) throw Error('Unsupported custom provider configuration');
+    const providers = doc.providers.map(validateProfile);
+    if (new Set(providers.map(p => p.id)).size !== providers.length) throw Error('Duplicate custom provider IDs');
+    return { providers, revision: createHash('sha256').update(raw).digest('hex') };
+  }
+  async update(revision, change) {
+    await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+    const lock = this.path + '.lock', temporary = this.path + '.' + randomUUID() + '.tmp';
+    const deadline = Date.now() + 3000;
+    for (;;) {
+      try { await mkdir(lock, { mode: 0o700 }); break; } catch (error) {
+        if (error.code !== 'EEXIST') throw error;
+        if (Date.now() >= deadline) throw Error('Custom provider configuration is locked by another process', { cause: error });
+        await new Promise(resolve => setTimeout(resolve, 50));
+      }
+    }
+    try {
+      const current = await this.read();
+      if (current.revision !== revision) throw Error('Custom providers changed in another window; reopen this editor');
+      const providers = (await change(current.providers)).map(validateProfile);
+      await writeFile(temporary, stringify({ version: 1, providers }), { mode: 0o600, flag: 'wx' });
+      await rename(temporary, this.path);
+      return await this.read();
+    } finally { await rm(temporary, { force: true }); await rm(lock, { recursive: true, force: true }); }
+  }
+}

package/plugins/custom/desktop-client.mjs

@@ -0,0 +1,150 @@
+// Shared Web/Desktop client. Draft keys live only in this mounted form.
+globalThis.__ModuleLoader__.load({
+  id: '@toddzheng024/dscode-desktop',
+  factory: require => {
+    const { createElement: h, useState, useEffect, useRef } = require('react');
+    const control = { padding: '8px 10px', border: '1px solid #8886', borderRadius: 6, background: 'transparent', color: 'inherit', font: 'inherit', boxSizing: 'border-box' };
+    const row = { display: 'flex', flexWrap: 'wrap', gap: 10, alignItems: 'center' };
+    const resetModel = model => {
+      const next = { ...model, thinking: 'default', inputModalities: ['text'] };
+      for (const [field, source] of [['contextWindow', 'contextSource'], ['maxTokens', 'outputSource']]) {
+        if (next[source] === 'server') { delete next[field]; delete next[source]; }
+      }
+      return next;
+    };
+    function Settings({ execute }) {
+      const [snapshot, setSnapshot] = useState(null), [draft, setDraft] = useState(null), [key, setKey] = useState('');
+      const [busy, setBusy] = useState(false), [error, setError] = useState(''), [notice, setNotice] = useState(''), [report, setReport] = useState(null), [removing, setRemoving] = useState(false);
+      const pending = useRef(false), alive = useRef(true), request = useRef(null);
+      const run = async (task, cancellable = false) => {
+        if (pending.current) return;
+        const controller = cancellable ? new AbortController() : null;
+        request.current = controller;
+        pending.current = true; setBusy(true); setError(''); setNotice('');
+        let cancellationFailed = false;
+        try { await task(controller?.signal); }
+        catch (error) {
+          cancellationFailed = error.cancellationFailed === true;
+          if (alive.current && (!controller?.signal.aborted || cancellationFailed)) setError(error.message);
+        }
+        finally {
+          request.current = null; pending.current = false;
+          if (alive.current) {
+            setBusy(false);
+            if (controller?.signal.aborted) setNotice(cancellationFailed ? 'Cancellation could not be confirmed.' : 'Request cancelled.');
+          }
+        }
+      };
+      const select = profile => { setDraft(profile ? { ...profile, models: profile.models.map(model => ({ ...model })) } : null); setKey(''); setReport(null); setRemoving(false); setNotice(''); };
+      const accept = value => { if (!alive.current) return; setSnapshot(value); select(value.providers.find(p => p.id === draft?.id) ?? value.providers[0]); };
+      useEffect(() => {
+        alive.current = true;
+        void run(async () => { accept(await execute('list')); });
+        return () => { alive.current = false; request.current?.abort(); };
+      }, []);
+      const change = values => { setDraft({ ...draft, ...values }); setReport(null); setRemoving(false); setNotice('Unsaved changes'); };
+      const modelChange = (index, values) => change({ models: draft.models.map((model, i) => i === index ? { ...model, ...values } : model) });
+      const button = (text, action, disabled = false, cancellable = false) => h('button', { type: 'button', style: { ...control, cursor: 'pointer' }, disabled: busy || disabled, onClick: () => run(action, cancellable) }, text);
+      const input = (label, value, onChange, options = {}) => h('label', { style: { display: 'grid', gap: 5, minWidth: 180, flex: 1 } }, label,
+        h('input', { 'aria-label': label, style: { ...control, width: '100%' }, value: value ?? '', onChange: event => onChange(event.target.value), ...options }));
+      const choice = (label, value, choices, onChange) => h('label', { style: { display: 'grid', gap: 5, flex: 1 } }, label,
+        h('select', { 'aria-label': label, value, onChange: event => onChange(event.target.value), style: control }, ...choices.map(([id, text]) => h('option', { key: id, value: id }, text))));
+      return h('section', { 'aria-label': 'DSCODE model settings', style: { padding: 20, display: 'grid', gap: 16, maxWidth: 850, color: 'inherit' } },
+        h('h2', { style: { margin: 0 } }, 'DSCODE models'),
+        h('p', { style: { margin: 0 } }, 'Connect a private or self-hosted model service. Saved models appear in the model picker.'),
+        error && h('div', { role: 'alert', style: { color: '#d85b5b', whiteSpace: 'pre-wrap' } }, error),
+        notice && h('div', { role: 'status' }, notice),
+        busy && request.current && h('button', { type: 'button', style: control, disabled: request.current.signal.aborted,
+          onClick: () => { request.current?.abort(); setNotice('Cancelling request…'); },
+        }, 'Cancel request'),
+        h('div', { style: row },
+          button('Reload (discard draft)', async () => accept(await execute('list'))),
+          button('Add provider', async () => { const value = await execute('new'); if (alive.current) select(value); }, !snapshot)),
+        h('fieldset', { disabled: busy || !snapshot, style: { border: 0, padding: 0, margin: 0, display: 'grid', gap: 16 } },
+          choice('Saved provider', snapshot?.providers.some(p => p.id === draft?.id) ? draft.id : '', [['', 'Choose a provider'], ...(snapshot?.providers ?? []).map(p => [p.id, p.name])], id => select(snapshot.providers.find(p => p.id === id))),
+          draft && h('div', { style: { display: 'grid', gap: 16 } },
+            h('div', { style: row }, input('Provider name', draft.name, name => change({ name })),
+              input('API base URL', draft.baseURL, baseURL => change({ baseURL, backend: 'generic', models: draft.models.map(resetModel) }), { placeholder: 'https://example.com/v1', type: 'url' })),
+            h('div', { style: row }, choice('API format', draft.api, [['chat-completions', 'Chat Completions'], ['responses', 'Responses'], ['anthropic', 'Anthropic Messages']], api => change({ api, auth: api === 'anthropic' ? 'x-api-key' : 'bearer', models: draft.models.map(resetModel) })),
+              choice('Authentication', draft.auth, [['bearer', 'Bearer token'], ['x-api-key', 'API key header'], ['none', 'None']], auth => change({ auth }))),
+            draft.auth !== 'none' && input('API key', key, value => { setKey(value); setReport(null); setRemoving(false); setNotice('Unsaved changes'); }, { type: 'password', autoComplete: 'off', spellCheck: false, placeholder: 'Leave blank to keep the saved key' }),
+            h('small', null, draft.credentialStatus ?? 'Not saved'),
+            h('div', { style: row }, button('Discover models', async signal => {
+              const found = await execute('discover', { profile: draft, key }, signal);
+              if (!alive.current || signal.aborted) return;
+              const models = [...draft.models];
+              for (const model of found.models) {
+                const index = models.findIndex(previous => previous.id === model.id), previous = models[index];
+                if (index < 0) models.push(model);
+                else models[index] = {
+                  ...previous, ...model, thinking: previous.thinking,
+                  ...(previous.contextSource === 'user' ? { contextWindow: previous.contextWindow, contextSource: 'user' } : {}),
+                  ...(previous.outputSource === 'user' ? { maxTokens: previous.maxTokens, outputSource: 'user' } : {}),
+                };
+              }
+              change({ backend: found.backend, models });
+              setNotice(`Found ${found.models.length} models. Confirm the context size and image support before saving.`);
+            }, false, true), button('Add model', async () => change({ models: [...draft.models, { id: '', thinking: 'default', inputModalities: ['text'] }] }))),
+            ...draft.models.map((model, index) => h('fieldset', { key: index, style: { border: '1px solid #8886', borderRadius: 8, padding: 14, display: 'grid', gap: 12 } },
+              h('legend', null, `Model ${index + 1}`),
+              h('div', { style: row }, input(`Model ${index + 1} ID`, model.id, id => change({ models: draft.models.map((entry, i) => i === index ? { ...resetModel(entry), id } : entry) })),
+                input(`Model ${index + 1} context`, model.contextWindow, value => modelChange(index, { contextWindow: value ? Number(value) : undefined, contextSource: 'user' }), { type: 'number', min: 1, step: 1 }),
+                input(`Model ${index + 1} output limit`, model.maxTokens, value => modelChange(index, { maxTokens: value ? Number(value) : undefined, outputSource: 'user' }), { type: 'number', min: 1, step: 1 })),
+              h('div', { style: row }, choice(`Model ${index + 1} thinking`, model.thinking ?? 'default', [['default', 'Provider default'], ['off', 'Off'], ['on', 'On']], thinking => modelChange(index, { thinking })),
+                h('label', null, h('input', { type: 'checkbox', 'aria-label': `Model ${index + 1} accepts images`, checked: model.inputModalities?.includes('image') ?? false,
+                  onChange: event => modelChange(index, { inputModalities: event.target.checked ? ['text', 'image'] : ['text'] }) }), ' Accepts images')),
+              h('div', { style: row }, button(`Test model ${index + 1}`, async signal => {
+                setReport(null);
+                const stages = await execute('test', { profile: draft, model: model.id, key }, signal);
+                if (alive.current && !signal.aborted) setReport({ model: model.id, stages });
+              }, !model.id || !model.contextWindow, true),
+                button(`Remove model ${index + 1}`, async () => change({ models: draft.models.filter((_, i) => i !== index) }))))),
+            h('p', { style: { margin: 0, fontSize: 13 } }, 'Tests send text and tool calls to this service and may incur usage. Image support is a manual setting; the test does not verify vision.'),
+            report && h('div', null,
+              h('h3', { style: { margin: 0 } }, `Test results: ${report.model}`),
+              h('ul', { 'aria-label': 'Model test results' }, ...report.stages.map((stage, index) => h('li', { key: index }, `${stage.name}: ${stage.status}${stage.message ? ` — ${stage.message}` : ''}`)))),
+            h('div', { style: row }, button('Save provider', async () => {
+              const saved = await execute('save', { profile: draft, key, revision: snapshot.revision });
+              if (alive.current) { accept(saved); setNotice('Provider saved. Select its model in a session.'); }
+            }, draft.models.length === 0 || draft.models.some(model => !model.contextWindow)),
+            snapshot?.providers.some(p => p.id === draft.id) && button(removing ? 'Confirm remove provider and key' : 'Remove provider', async () => {
+              if (!removing) { setRemoving(true); return; }
+              const saved = await execute('remove', { id: draft.id, revision: snapshot.revision });
+              if (alive.current) { accept(saved); setNotice('Provider removed.'); }
+            })))));
+    }
+    return {
+      inject: ['slots', 'connection'],
+      apply(ctx) {
+        ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'dscode-models', order: 11, label: () => 'DSCODE models',
+          inject: () => ({ execute: async (action, args = {}, signal) => {
+            signal?.throwIfAborted();
+            const requestId = signal ? crypto.randomUUID() : undefined;
+            let cancellation;
+            const cancel = () => {
+              cancellation ??= ctx.connection.rpc.call('/api', 'dscode-custom', { action: 'cancel', requestId }, AbortSignal.timeout(10000))
+                .then(response => response.ok ? null : response.error.message, error => error.message);
+            };
+            signal?.addEventListener('abort', cancel, { once: true });
+            let response, requestError;
+            try {
+              response = await ctx.connection.rpc.call('/api', 'dscode-custom', { action, ...args, ...(requestId ? { requestId } : {}) }, signal);
+            } catch (error) { requestError = error; }
+            finally { signal?.removeEventListener('abort', cancel); }
+            if (cancellation) {
+              const failure = await cancellation;
+              if (failure) {
+                const error = Error('Could not confirm server cancellation. The request may still be running: ' + failure);
+                error.cancellationFailed = true;
+                throw error;
+              }
+            }
+            if (requestError) throw requestError;
+            if (!response.ok) throw Error(response.error.message);
+            return response.value;
+          } }),
+        }, Settings));
+      },
+    };
+  },
+});

package/plugins/custom/desktop-host.mjs

@@ -0,0 +1,78 @@
+import { clientRequestSchema } from '@deepseek-ai/dsh-client-connection';
+
+/** UI-only configuration transport; never registers an Agent tool or command. */
+export async function customRequest(service, payload, signal) {
+  if (!service) throw Error('Custom model configuration is unavailable.');
+  if (!payload || typeof payload !== 'object') throw Error('Invalid custom model request.');
+  const key = payload.key ?? '';
+  if (typeof key !== 'string' || key.length > 4096) throw Error('Invalid API key.');
+  if (['save', 'remove'].includes(payload.action) && typeof payload.revision !== 'string') throw Error('Reload the saved providers before making changes.');
+  switch (payload.action) {
+    case 'list': return service.list();
+    case 'new': return service.newProfile();
+    case 'save': return service.save(payload.profile, key, payload.revision);
+    case 'remove': return service.remove(payload.id, payload.revision);
+    case 'discover': return service.discover(payload.profile, key, signal);
+    case 'test': return service.test(payload.profile, payload.model, key, signal);
+    default: throw Error('Unknown custom model action.');
+  }
+}
+
+export function apply(ctx) {
+  ctx.inject(['connection'], scope => {
+    // Electron's application-protocol proxy may keep its upstream HTTP request
+    // alive after renderer fetch aborts. Explicit cancellation covers that hop.
+    const operations = new Map();
+    const operation = id => {
+      if (typeof id !== 'string' || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(id)) throw Error('Invalid request ID.');
+      for (const [key, entry] of operations) if (entry.expires <= Date.now()) operations.delete(key);
+      let entry = operations.get(id);
+      if (!entry) {
+        if (operations.size >= 128) throw Error('Too many model requests; try again shortly.');
+        entry = { controller: new AbortController(), started: false, expires: Date.now() + 60000 };
+        operations.set(id, entry);
+      }
+      return entry;
+    };
+    scope.effect(() => {
+      const unregister = scope.connection.fetch.register({ path: '/api/dscode-custom', methods: ['POST'], requestBody: 'buffered',
+        fetch: async request => {
+          let body;
+          try { body = await request.json(); } catch { return new Response('Invalid JSON', { status: 400 }); }
+          const parsed = clientRequestSchema.safeParse(body);
+          if (!parsed.success || parsed.data.method !== 'dscode-custom') return new Response('Invalid custom model request', { status: 400 });
+          const { rpcId, payload } = parsed.data;
+          let result, tracked;
+          try {
+            // Discovery and inference enforce their own timeouts. A transport-wide
+            // deadline would cut short a valid cold start or active streamed test.
+            if (payload?.action === 'cancel') {
+              operation(payload.requestId).controller.abort();
+              result = { ok: true, value: null };
+            } else {
+              if (payload?.requestId !== undefined) {
+                if (!['discover', 'test'].includes(payload.action)) throw Error('Only discovery and tests support cancellation.');
+                const entry = operation(payload.requestId);
+                entry.controller.signal.throwIfAborted();
+                if (entry.started) throw Error('Request ID already used.');
+                tracked = entry; tracked.started = true; tracked.expires = Infinity;
+              }
+              const signal = tracked ? AbortSignal.any([request.signal, tracked.controller.signal]) : request.signal;
+              result = { ok: true, value: await customRequest(ctx.get('dscodeCustom'), payload, signal) };
+            }
+          } catch (error) {
+            const secret = typeof payload?.key === 'string' ? payload.key : '';
+            const message = String(error.message ?? 'Custom model request failed.');
+            result = { ok: false, error: { code: 'dscode-custom', message: secret ? message.replaceAll(secret, '[redacted]') : message, details: {} } };
+          }
+          finally { if (tracked) tracked.expires = Date.now() + 60000; }
+          return Response.json({ type: 'server-response', rpcId, result }, { headers: { 'Cache-Control': 'no-store' } });
+        },
+      });
+      return () => {
+        for (const entry of operations.values()) entry.controller.abort();
+        operations.clear(); unregister();
+      };
+    }, 'dscode-custom.rpc');
+  }).then(undefined, error => { ctx.logger.error(`Custom model transport failed: ${error.message}`); });
+}

package/plugins/custom/images.mjs

@@ -0,0 +1,32 @@
+import { IMAGE_OFFLOAD_REQUIRED_CODE, LlmError, contentHasImage, offloadedImageText, projectOffloadedImages, requiredImageOffload } from '@deepseek-ai/dsh-llm';
+import { requestImageDimensions } from '@deepseek-ai/dsh-attachment';
+
+const IMAGE_POLICY = Object.freeze({ maxPixels: 2048 * 2048, maxBytes: 1024 * 1024 });
+const MAX_REQUEST_IMAGE_BYTES = 20 * 1024 * 1024;
+
+/** Read durable images once per attachment; offloading remains a session decision. */
+export async function prepareImages(history, model, attachments, access, signal) {
+  const messages = projectOffloadedImages(history, ref => offloadedImageText(ref, access(ref)));
+  const versions = new Map();
+  if (!messages.some(m => contentHasImage(m.content))) return { messages, versions, access };
+  if (!model.inputModalities?.includes('image')) throw new LlmError('Enable image input for this custom model before sending retained images', 'UNSUPPORTED_CONTENT');
+  if (!attachments) throw new LlmError('Image input requires the durable attachment service', 'UNSUPPORTED_CONTENT');
+  const refs = new Map();
+  const collect = blocks => {
+    for (const block of blocks) {
+      if (block.type === 'image') refs.set(block.attachment.attachmentId, block.attachment);
+      else if (block.type === 'tool-result') collect(block.content);
+    }
+  };
+  for (const message of messages) collect(message.content);
+  for (const ref of refs.values()) {
+    signal?.throwIfAborted();
+    const target = { ...requestImageDimensions(ref.width, ref.height, IMAGE_POLICY.maxPixels), maxBytes: IMAGE_POLICY.maxBytes };
+    versions.set(ref.attachmentId, await attachments.readImageRequest(ref, target, signal));
+  }
+  const offloadImages = requiredImageOffload(messages,
+    { representation: 'base64', maxBytes: MAX_REQUEST_IMAGE_BYTES, byteQuantum: 1 },
+    block => versions.get(block.attachment.attachmentId).bytes);
+  if (offloadImages > 0) throw new LlmError('Custom request images exceed the 20 MiB encoded image budget', IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages });
+  return { messages, versions, access };
+}