@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/plugins/openrouter/wire.mjs

@@ -0,0 +1,101 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { serializeMessages } from '../providers/chat-messages.mjs';
+export { serializeMessages } from '../providers/chat-messages.mjs';
+export { sseData, mapUsage, translate } from '../providers/chat-stream.mjs';
+export { errorCode, errorMessage, retryAfterMs } from '../providers/http-errors.mjs';
+import { OPENROUTER_EFFORTS } from '../providers/catalog.mjs';
+import { ultraRequest } from '../ultra/policy.mjs';
+
+// OpenRouter chat completions on the wire: request bodies, the SSE stream, and
+// the translation into harness stream chunks. Pure functions; the adapter owns I/O.
+
+export const PROVIDER = 'openrouter';
+/** `replayState.response.kind` for responses this adapter produced. */
+export const REPLAY_KIND = 'dscode-openrouter';
+// OpenRouter serves DeepSeek V4 thinking as none/high/xhigh; the route keeps the
+// official off/low/high/max detents (and Ultra on max) with the spelling it accepts.
+const DEEPSEEK_WIRE = Object.freeze({ ...OPENROUTER_EFFORTS, ultra: OPENROUTER_EFFORTS.max });
+const DEEPSEEK_V4 = /^deepseek\/deepseek-v4/;
+// Alibaba caches only at explicit breakpoints.
+const EXPLICIT_CACHE_MODELS = /^qwen\//;
+const DEFAULT_LEVELS = ['low', 'medium', 'high'];
+// OpenRouter picks the upstream endpoint, but only among endpoints that honour every
+// request parameter (by default it silently drops unsupported ones) and that do not
+// serve fp4-quantized weights. INT4 stays: Kimi ships native INT4 weights.
+const ROUTING = Object.freeze({ require_parameters: true, quantizations: Object.freeze(['int4', 'int8', 'fp6', 'fp8', 'mxfp8', 'fp16', 'bf16', 'fp32', 'unknown']) });
+const NAMES = { off: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'XHigh', max: 'Max', ultra: 'Ultra' };
+export const ULTRA_DESCRIPTION = 'DSCODE: max reasoning plus deliberate subagent collaboration; higher total token use.';
+
+/**
+ * Reasoning controls a model offers through this route.
+ * @param model - OpenRouter model id.
+ * @param entry - the model's listing entry, if any.
+ * @returns `{ levels, defaultEffort?, wire }` with harness effort ids and their wire
+ *   spelling, or undefined when the model has no reasoning control.
+ */
+export function modelReasoning(model, entry) {
+  if (DEEPSEEK_V4.test(model)) return { levels: ['off', 'low', 'high', 'max', 'ultra'], defaultEffort: 'high', wire: DEEPSEEK_WIRE };
+  const reasoning = entry?.reasoning;
+  if (!reasoning) return undefined;
+  // No allowlist means OpenRouter maps any standard level; offer the common three.
+  const levels = reasoning.efforts ?? DEFAULT_LEVELS;
+  const ultra = levels.includes('max');
+  const wire = Object.fromEntries([...(reasoning.mandatory ? [] : [['off', 'none']]), ...levels.map(level => [level, level]), ...(ultra ? [['ultra', 'max']] : [])]);
+  // Like the official route, requests default to high; a model without high keeps its own default.
+  const defaultEffort = levels.includes('high') ? 'high' : levels.includes(reasoning.defaultEffort) ? reasoning.defaultEffort : undefined;
+  return { levels: Object.keys(wire), ...(defaultEffort ? { defaultEffort } : {}), wire };
+}
+
+/** Display metadata for one harness effort id. */
+export function effortInfo(id) {
+  return { id, name: NAMES[id] ?? id, ...(id === 'ultra' ? { description: ULTRA_DESCRIPTION } : {}) };
+}
+
+/** A title needs no deliberation: reasoning off when the model allows it, else its lowest level. */
+function titleEffort(reasoning) {
+  return reasoning.wire.off !== undefined ? 'off' : reasoning.levels.find(level => level !== 'ultra');
+}
+
+const cacheMarked = content => typeof content === 'string'
+  ? [{ type: 'text', text: content, cache_control: { type: 'ephemeral' } }]
+  : content.map((part, index) => index === content.findLastIndex(candidate => candidate.type === 'text') ? { ...part, cache_control: { type: 'ephemeral' } } : part);
+
+/** Explicit cache breakpoints for models that cache only at them: the system prompt and the latest user turn. */
+export function withCacheBreakpoints(messages, model) {
+  if (!EXPLICIT_CACHE_MODELS.test(model)) return messages;
+  const targets = new Set([messages.findIndex(message => message.role === 'system'), messages.findLastIndex(message => message.role === 'user')]);
+  return messages.map((message, index) => targets.has(index) && message.content !== '' ? { ...message, content: cacheMarked(message.content) } : message);
+}
+
+/**
+ * The chat-completions body for one harness request.
+ * @param options - harness request (images already prepared into `images`).
+ * @param context - `{ entry, images }`: the model's listing entry and prepared request images.
+ */
+export function requestBody(options, { entry, images } = {}) {
+  const reasoning = modelReasoning(options.model, entry);
+  const effort = options.purpose === 'session-title' && reasoning ? titleEffort(reasoning) : options.reasoningEffort;
+  const wireEffort = effort === undefined ? undefined : reasoning?.wire[effort];
+  if (effort !== undefined && reasoning !== undefined && wireEffort === undefined) {
+    throw new LlmError(`OpenRouter model "${options.model}" does not offer reasoning effort "${effort}"`, 'UNSUPPORTED_REASONING_EFFORT');
+  }
+  let messages = serializeMessages(options.messages, { model: options.model, system: options.system, images, dialect: { provider: options.provider ?? PROVIDER } });
+  messages = withCacheBreakpoints(ultraRequest(options, messages), options.model);
+  // Delegation tools are offered at every effort; workflow and ralph never are.
+  const tools = (options.tools ?? []).filter(tool => tool.name !== 'workflow' && tool.name !== 'ralph')
+    .map(tool => ({ type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } }));
+  return {
+    model: options.model,
+    messages,
+    stream: true,
+    ...(tools.length > 0 ? { tools } : {}),
+    ...(wireEffort !== undefined ? { reasoning: { effort: wireEffort } } : {}),
+    // Endpoints declare `max_tokens`; `max_completion_tokens` would fail `require_parameters` almost everywhere.
+    ...(options.maxTokens !== undefined ? { max_tokens: options.maxTokens } : {}),
+    ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+    ...(options.stop !== undefined ? { stop: options.stop } : {}),
+    // The sticky-routing key: one session keeps one upstream endpoint and its warm cache.
+    ...(options.sessionId !== undefined ? { session_id: String(options.sessionId).slice(0, 256) } : {}),
+    provider: { require_parameters: ROUTING.require_parameters, quantizations: [...ROUTING.quantizations] },
+  };
+}

package/plugins/providers/catalog.mjs

@@ -0,0 +1,160 @@
+// Model providers `/provider` switches between. DeepSeek's official API is the
+// native `llm-deepseek` route; OpenRouter is DSCODE's own adapter
+// (plugins/openrouter), which serves OpenRouter's live model listing and is always
+// registered, as are the Grok and OpenCode Go routes. This module ships beside the TUI too, so it imports nothing.
+
+export const PROVIDERS = Object.freeze([
+  { id: 'deepseek-official', name: 'DeepSeek', aliases: ['deepseek', 'deepseek-official', 'official'], credentialRef: 'DEEPSEEK_API_KEY', defaultModel: 'deepseek-flash' },
+  // The optional management key reads account data only; it cannot call models.
+  { id: 'openrouter', name: 'OpenRouter', aliases: ['openrouter', 'open-router'], credentialRef: 'OPENROUTER_API_KEY', managementRef: 'OPENROUTER_MANAGEMENT_KEY', defaultModel: 'deepseek/deepseek-v4-flash' },
+  // The Grok subscription rail: the token is the local 'grok login', read-only (plugins/grok).
+  { id: 'grok', name: 'Grok', aliases: ['grok', 'xai', 'x-ai'], credentialRef: 'GROK_CLI_TOKEN', defaultModel: 'grok-4.6' },
+  // The OpenCode Go subscription: its chat-completions models, authorised only by an OpenCode
+  // account login. `login` names the command that sets the credential up; there is no key to paste.
+  { id: 'opencode-go', name: 'OpenCode Go', aliases: ['opencode-go', 'opencode', 'go'], credentialRef: 'OPENCODE_OAUTH', login: '/opencode login', defaultModel: 'kimi-k3' },
+]);
+
+// The pi-ai adapter served OpenRouter until 0.7.6, from this settings section.
+const PI_AI_NS = 'llm-pi-ai';
+
+// OpenRouter serves DeepSeek V4 thinking as none/high/xhigh. DeepSeek itself
+// answers `low` as high and `max` as xhigh, so the route offers the official
+// low/high/max detents (and Ultra on top of max) with the wire spelling OpenRouter
+// accepts; session cards and delegated children that ask for `low` keep working.
+export const OPENROUTER_EFFORTS = Object.freeze({ off: 'none', low: 'high', high: 'high', max: 'xhigh' });
+
+/** The DeepSeek models the OpenRouter route serves, with their official-route counterparts. */
+export const OPENROUTER_MODELS = Object.freeze([
+  { id: 'deepseek/deepseek-v4-flash', name: 'DeepSeek V4 Flash', official: ['deepseek-flash', 'deepseek-v4-flash'] },
+  { id: 'deepseek/deepseek-v4-pro', name: 'DeepSeek V4 Pro', official: ['deepseek-v4-pro'] },
+  { id: 'deepseek/deepseek-v4-flash-vision-exp', name: 'DeepSeek V4 Flash Vision Exp', official: ['deepseek-v4-flash-vision-exp'] },
+]);
+
+/**
+ * Remove the `openrouter` profile earlier builds wrote into the pi-ai section. The
+ * pi-ai adapter is no longer mounted, so the profile is inert, and it would claim the
+ * route a second time if that adapter were ever mounted again.
+ * Never throws: /model and /provider must open regardless.
+ * @returns whether the settings changed.
+ */
+export async function migrateOpenRouterProfile(settings) {
+  try {
+    const descriptor = settings?.describe?.({ redactSecrets: true }).find(entry => entry.ns === PI_AI_NS);
+    if (!descriptor || settings.writable !== true || descriptor.value?.providers?.openrouter === undefined) return false;
+    await settings.mutate(PI_AI_NS, [{ op: 'unset', path: ['providers', 'openrouter'] }], descriptor.revision);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function providerSpec(id) {
+  if (canonicalProvider(id) !== id) {
+    const provider = PROVIDERS.find(provider => provider.id === canonicalProvider(id));
+    return { ...provider, id, name: `DSCODE ${provider.name}` };
+  }
+  return PROVIDERS.find(provider => provider.id === id) ?? (typeof id === 'string' && /^custom-[a-zA-Z0-9-]+$/.test(id) ? { id, name: 'Custom', aliases: [id] } : undefined);
+}
+
+/** Desktop keeps its enhanced adapter separate from the native pi-ai route. */
+export const canonicalProvider = provider => provider === 'dscode-openrouter' ? 'openrouter' : provider === 'dscode-opencode-go' ? 'opencode-go' : provider;
+export const isOpenRouterRoute = provider => canonicalProvider(provider) === 'openrouter';
+
+/**
+ * Resolve a `/provider` or `/login` argument.
+ * @param raw - text after the command name.
+ * @returns a provider id, `undefined` for no argument, or `null` when unrecognized. Callers must not echo the text: it may be a pasted key.
+ */
+export function providerArgument(raw) {
+  const value = String(raw ?? '').trim().toLowerCase();
+  if (value === '') return undefined;
+  if (value === 'custom') return 'custom';
+  return PROVIDERS.find(provider => provider.aliases.includes(value))?.id ?? null;
+}
+
+/** Split a `provider/model` label at the first slash: OpenRouter model ids carry their own `vendor/` segment. */
+export function splitModelLabel(label) {
+  const text = typeof label === 'string' ? label : '';
+  const cut = text.indexOf('/');
+  return cut > 0 ? { provider: text.slice(0, cut), model: text.slice(cut + 1) } : { provider: '', model: text };
+}
+
+/** The switchable provider a label names, defaulting to DeepSeek for unknown or bare labels. */
+export function providerOfLabel(label) {
+  return providerSpec(splitModelLabel(label).provider)?.id ?? PROVIDERS[0].id;
+}
+
+/** Provider id leading a footer header (`provider: model @ effort`), if any. */
+export function providerOfHeader(header) {
+  return typeof header === 'string' ? header.match(/^([^\s:/]+): /)?.[1] : undefined;
+}
+
+// OpenCode Go names DeepSeek models by the official ids, without OpenRouter's vendor segment.
+const OPENCODE_GO_OFFICIAL = Object.freeze({ 'deepseek-flash': 'deepseek-v4-flash' });
+
+function counterpart(from, model, to) {
+  from = canonicalProvider(from);
+  to = canonicalProvider(to);
+  if (from === to) return model;
+  if (from === 'deepseek-official' && to === 'openrouter') return OPENROUTER_MODELS.find(entry => entry.official.includes(model))?.id;
+  if (from === 'openrouter' && to === 'deepseek-official') return OPENROUTER_MODELS.find(entry => entry.id === model)?.official[0];
+  if (from === 'deepseek-official' && to === 'opencode-go') return OPENCODE_GO_OFFICIAL[model] ?? model;
+  if (from === 'opencode-go' && to === 'deepseek-official') return model;
+  // OpenRouter's `vendor/model` ids mostly end in Go's own id.
+  if (from === 'openrouter' && to === 'opencode-go') return model.slice(model.indexOf('/') + 1);
+  return undefined;
+}
+
+/**
+ * The model a provider switch lands on: the current model's counterpart, else the
+ * provider default, else its first model. The effort carries over only when the
+ * target offers it; otherwise the model's own default applies.
+ * @param rows - model directory rows (`provider`, `model`, `reasoning`).
+ * @returns `{ row, effort }`, or `undefined` when the provider serves no model yet.
+ */
+export function pickModel(rows, provider, currentLabel, effort) {
+  const candidates = rows.filter(row => row.provider === provider);
+  if (candidates.length === 0) return undefined;
+  const current = splitModelLabel(currentLabel);
+  const wanted = counterpart(current.provider, current.model, provider);
+  const row = candidates.find(candidate => candidate.model === wanted)
+    ?? candidates.find(candidate => candidate.model === providerSpec(provider)?.defaultModel)
+    ?? candidates[0];
+  const offered = row.reasoning?.efforts.map(level => level.id) ?? [];
+  return { row, effort: effort && offered.includes(effort) ? effort : undefined };
+}
+
+/**
+ * Credential status of a provider-settings row.
+ * @returns `saved`, `env`, `account` (signed in with an account instead of a key), `missing`,
+ *   `readonly` (an empty read-only source), `error`, or `unavailable` (no row).
+ */
+export function credentialState(row) {
+  if (!row) return 'unavailable';
+  const credential = row.credential;
+  if (credential?.kind === 'error') return 'error';
+  if (credential?.kind !== 'facts') return 'missing';
+  if (credential.configured) return credential.source === 'env' ? 'env' : credential.source === 'account' ? 'account' : 'saved';
+  return credential.writable ? 'missing' : 'readonly';
+}
+
+/**
+ * Prepare a provider before a switch. Both routes are always registered; switching
+ * to OpenRouter only clears the inert pi-ai profile earlier builds wrote.
+ * @param settings - the host settings service.
+ * @returns whether the settings changed.
+ */
+export async function ensureProviderRoute(settings, provider) {
+  return provider === 'openrouter' ? migrateOpenRouterProfile(settings) : false;
+}
+
+/** Wait for a route's models to reach the model directory. */
+export async function waitForModels(loadModels, provider, { attempts = 30, delayMs = 100 } = {}) {
+  let directory;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    directory = await loadModels();
+    if (directory.rows.some(row => row.provider === provider)) return directory;
+    await new Promise(resolve => setTimeout(resolve, delayMs));
+  }
+  return directory;
+}

package/plugins/providers/chat-messages.mjs

@@ -0,0 +1,120 @@
+import { requestImageHandleText, textOnlyImageText } from '@deepseek-ai/dsh-llm';
+
+const TOOL_RESULT_IMAGE_TEXT = 'Attached image(s) from tool result:';
+// Legacy OpenRouter defaults; other protocols supply an explicit dialect.
+const REASONING_CONTENT_MODELS = /^(?:deepseek\/deepseek-v4|moonshotai\/kimi-k2\.6|xiaomi\/mimo-v2\.6)/;
+
+const textOf = blocks => blocks.filter(block => block.type === 'text').map(block => block.text).join('');
+
+function contentParts(blocks, images) {
+  const parts = [];
+  for (const block of blocks) {
+    if (block.type === 'text' && block.text.length > 0) parts.push({ type: 'text', text: block.text });
+    else if (block.type === 'image') {
+      const version = images?.versions.get(block.attachment.attachmentId);
+      if (version === undefined) { parts.push({ type: 'text', text: textOnlyImageText(block.attachment) }); continue; }
+      parts.push({ type: 'text', text: requestImageHandleText(block.attachment, version, images.access?.(block.attachment)) });
+      parts.push({ type: 'image_url', image_url: { url: `data:${version.mediaType};base64,${Buffer.from(version.data).toString('base64')}` } });
+    }
+  }
+  return parts;
+}
+
+const collapse = parts => parts.every(part => part.type === 'text') ? parts.map(part => part.text).join('') : parts;
+
+/** Reasoning details this adapter (or the pi-ai adapter before it) stored for a same-model replay. */
+function replayedDetails(message) {
+  const blocks = message.source?.replayState?.blocks;
+  if (!Array.isArray(blocks) || blocks.length !== message.content.length) return [];
+  const details = [];
+  blocks.forEach((block, index) => {
+    if (message.content[index]?.type !== 'reasoning') return;
+    if (Array.isArray(block?.reasoningDetails)) details.push(...block.reasoningDetails);
+    else if (typeof block?.thinkingSignature === 'string') {
+      try {
+        const parsed = JSON.parse(block.thinkingSignature);
+        if (Array.isArray(parsed)) details.push(...parsed);
+      } catch { /* a plain field-name signature carries no details */ }
+    }
+  });
+  return details;
+}
+
+function serializeAssistant(message, model, dialect) {
+  const text = textOf(message.content);
+  const calls = message.content.filter(block => block.type === 'tool-call')
+    .map(block => ({ id: block.id, type: 'function', function: { name: block.name, arguments: block.arguments } }));
+  // An empty assistant turn (reasoning only) has nothing a provider accepts.
+  if (text.length === 0 && calls.length === 0) return undefined;
+  // Reasoning replays only to the model that produced it.
+  const sameModel = message.source?.provider === dialect.provider && message.source?.model === model;
+  const reasoning = sameModel ? message.content.filter(block => block.type === 'reasoning').map(block => block.text).join('') : '';
+  if (dialect.reasoningContent !== undefined) {
+    // A pass-through route speaks the upstream's own field: the reasoning text itself, or an
+    // empty one for models that reject a tool-call turn without it.
+    const field = reasoning.length > 0 ? reasoning : dialect.reasoningContent(model) ? '' : undefined;
+    return { role: 'assistant', content: text, ...(calls.length > 0 ? { tool_calls: calls } : {}), ...(field !== undefined ? { reasoning_content: field } : {}) };
+  }
+  const details = sameModel ? replayedDetails(message) : [];
+  return {
+    role: 'assistant',
+    content: text,
+    ...(calls.length > 0 ? { tool_calls: calls } : {}),
+    ...(details.length > 0 ? { reasoning_details: details } : reasoning.length > 0 ? { reasoning } : {}),
+    ...(REASONING_CONTENT_MODELS.test(model) ? { reasoning_content: '' } : {}),
+  };
+}
+
+/**
+ * Harness history as OpenRouter chat messages. Each tool result becomes a `tool`
+ * message; its images follow in one user message, which `tool` content cannot carry.
+ * @param images - prepared request images (`versions` by attachment id, `access`), when the request has any.
+ * @param dialect - another chat-completions route reusing this serializer: its `provider` id (whose
+ *   reasoning replays), and `reasoningContent(model)` to replay reasoning as `reasoning_content`.
+ */
+export function serializeMessages(messages, { model, system, images, dialect = { provider: 'openrouter' } } = {}) {
+  const wire = [];
+  if (system !== undefined && system.length > 0) wire.push({ role: 'system', content: system });
+  let pendingImages = [];
+  const flush = () => {
+    if (pendingImages.length === 0) return;
+    wire.push({ role: 'user', content: [{ type: 'text', text: TOOL_RESULT_IMAGE_TEXT }, ...pendingImages] });
+    pendingImages = [];
+  };
+  const appendResult = (callId, content) => {
+    const nested = contentParts(content, images);
+    const text = nested.filter(part => part.type === 'text').map(part => part.text).join('');
+    const attached = nested.filter(part => part.type !== 'text');
+    wire.push({ role: 'tool', tool_call_id: callId, content: text || (attached.length > 0 ? '(see attached image)' : '(no output)') });
+    pendingImages.push(...attached);
+  };
+  for (const message of messages) {
+    if (message.role === 'system') {
+      flush();
+      const text = textOf(message.content);
+      if (text.length > 0) wire.push({ role: 'system', content: text });
+      continue;
+    }
+    if (message.role === 'tool') {
+      appendResult(message.toolCallId, message.content);
+      continue;
+    }
+    if (message.role === 'assistant') {
+      flush();
+      const entry = serializeAssistant(message, model, dialect);
+      if (entry) wire.push(entry);
+      continue;
+    }
+    const results = message.content.filter(block => block.type === 'tool-result');
+    const parts = contentParts(message.content.filter(block => block.type !== 'tool-result'), images);
+    if (parts.length > 0 || results.length === 0) {
+      flush();
+      wire.push({ role: 'user', content: collapse(parts) });
+    }
+    for (const result of results) {
+      appendResult(result.toolCallId, result.content);
+    }
+  }
+  flush();
+  return wire;
+}

package/plugins/providers/chat-stream.mjs

@@ -0,0 +1,174 @@
+import { LlmError, EMPTY_RESPONSE_CODE } from '@deepseek-ai/dsh-llm';
+import { errorCode, errorMessage } from './http-errors.mjs';
+
+/**
+ * SSE `data:` payloads from a response body, skipping `:` keep-alive comments.
+ * @param onActivity - called for every received chunk, comments included.
+ */
+export async function* sseData(body, onActivity) {
+  const decoder = new TextDecoder();
+  let buffer = '', data = [];
+  const lines = function* (final) {
+    let newline;
+    while ((newline = buffer.indexOf('\n')) >= 0 || final && buffer.length > 0) {
+      let line = newline >= 0 ? buffer.slice(0, newline) : buffer;
+      buffer = newline >= 0 ? buffer.slice(newline + 1) : '';
+      if (line.endsWith('\r')) line = line.slice(0, -1);
+      if (line === '') {
+        // A bare `data:` line assembles to whitespace; the SSE spec reads it as a newline, but every consumer here parses JSON.
+        const payload = data.join('\n');
+        if (payload.trim() !== '') yield payload;
+        data = [];
+      } else if (line.startsWith('data:')) data.push(line.slice(line.startsWith('data: ') ? 6 : 5));
+    }
+  };
+  for await (const chunk of body) {
+    onActivity?.();
+    buffer += decoder.decode(chunk, { stream: true });
+    yield* lines(false);
+  }
+  buffer += decoder.decode();
+  yield* lines(true);
+  const tail = data.join('\n');
+  if (tail.trim() !== '') yield tail;
+}
+
+/** Map OpenRouter usage to disjoint harness counts (`prompt_tokens` includes cache reads and writes). */
+export function mapUsage(usage) {
+  const valid = value => Number.isSafeInteger(value) && value >= 0;
+  const prompt = usage?.prompt_tokens, completion = usage?.completion_tokens;
+  if (!valid(prompt) || !valid(completion)) return undefined;
+  const read = valid(usage.prompt_tokens_details?.cached_tokens) ? usage.prompt_tokens_details.cached_tokens : 0;
+  const write = valid(usage.prompt_tokens_details?.cache_write_tokens) ? usage.prompt_tokens_details.cache_write_tokens : 0;
+  const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+  return {
+    inputTokens: Math.max(0, prompt - read - write),
+    outputTokens: completion,
+    ...(usage.total_tokens === undefined || usage.total_tokens === prompt + completion ? { totalTokens: prompt + completion } : {}),
+    ...(read > 0 ? { cacheReadTokens: read } : {}),
+    ...(write > 0 ? { cacheWriteTokens: write } : {}),
+    ...(valid(reasoning) && reasoning > 0 ? { reasoningTokens: reasoning } : {}),
+  };
+}
+
+/** Streamed reasoning details merged into the blocks a replay sends back unmodified. */
+function mergeDetails(items) {
+  const merged = [];
+  for (const item of items) {
+    if (item === null || typeof item !== 'object') continue;
+    const last = merged.at(-1);
+    if (last && last.type === item.type && item.type !== 'reasoning.encrypted' && (last.index ?? 0) === (item.index ?? 0)) {
+      if (typeof item.text === 'string') last.text = (last.text ?? '') + item.text;
+      if (typeof item.summary === 'string') last.summary = (last.summary ?? '') + item.summary;
+      for (const key of ['id', 'format', 'signature']) if (item[key] !== undefined && item[key] !== null && item[key] !== '') last[key] = item[key];
+    } else merged.push({ ...item });
+  }
+  return merged;
+}
+
+function closeBlock(block) {
+  if (block.kind === 'tool-call') return { type: 'tool-call', id: block.callId ?? '', name: block.name ?? '', arguments: block.text };
+  return { type: block.kind, text: block.text };
+}
+
+function finishReason(reason, blocks, label) {
+  if (reason === 'length') return { kind: 'max-tokens' };
+  if (reason === 'content_filter') return { kind: 'error', failure: { message: `${label} stopped the response for content filtering`, code: 'CONTENT_FILTER' } };
+  if (reason === 'tool_calls' || blocks.some(block => block.kind === 'tool-call') && (reason === undefined || reason === 'stop')) return { kind: 'tool-calls' };
+  if (reason === undefined || reason === null || reason === 'stop' || reason === 'end') {
+    return blocks.length === 0 ? { kind: 'error', failure: { message: 'model returned a completed response with no content', code: EMPTY_RESPONSE_CODE } } : { kind: 'stop' };
+  }
+  return { kind: 'error', failure: { message: `model stopped: ${reason}`, code: String(reason).toUpperCase() } };
+}
+
+/**
+ * Translate SSE payloads into harness chunks. Block ends, usage and the finish are
+ * held until `[DONE]`; the finish of a successful response carries the replay state:
+ * reasoning details per block, the generation id, the serving provider and the billed cost.
+ * An error inside the stream throws with its routed code.
+ * @param kind - the replay kind stamped on the response; `label` names the route in errors.
+ */
+export async function* translate(payloads, { model, kind = 'dscode-openrouter', label = 'OpenRouter' }) {
+  let nextIndex = 0, textBlock, reasoningBlock, finish, usage, cost, id, provider;
+  const tools = new Map();
+  const order = [];
+  const open = kind => {
+    const block = { index: nextIndex++, kind, text: '', details: [] };
+    order.push(block);
+    return block;
+  };
+  for await (const payload of payloads) {
+    if (payload === '[DONE]') {
+      for (const block of order) yield { type: 'block-end', index: block.index, block: closeBlock(block) };
+      if (usage) yield { type: 'usage', usage };
+      const reason = finishReason(finish, order, label);
+      const succeeded = reason.kind === 'stop' || reason.kind === 'tool-calls' || reason.kind === 'max-tokens';
+      yield {
+        type: 'finish', reason,
+        ...(succeeded ? { replayState: {
+          response: { kind, version: 1, model, ...(id ? { id } : {}), ...(provider ? { provider } : {}), ...(cost !== undefined ? { cost } : {}) },
+          blocks: order.map(block => block.kind === 'reasoning' && block.details.length > 0 ? { type: 'reasoning', reasoningDetails: mergeDetails(block.details) } : { type: block.kind }),
+        } } : {}),
+      };
+      return;
+    }
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      throw new LlmError(`malformed ${label} stream payload: ${payload.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+    }
+    if (chunk?.error) {
+      const status = Number.isInteger(chunk.error.code) ? chunk.error.code : undefined;
+      throw new LlmError(errorMessage(chunk.error, `${label} stream error`), errorCode(undefined, chunk.error), status === undefined ? {} : { status });
+    }
+    if (typeof chunk?.id === 'string') id ??= chunk.id;
+    if (typeof chunk?.provider === 'string') provider ??= chunk.provider;
+    for (const choice of chunk?.choices ?? []) {
+      const delta = choice.delta ?? {};
+      const details = Array.isArray(delta.reasoning_details) ? delta.reasoning_details : [];
+      let reasoning = typeof delta.reasoning === 'string' ? delta.reasoning : typeof delta.reasoning_content === 'string' ? delta.reasoning_content : '';
+      if (reasoning.length === 0) reasoning = details.map(detail => detail?.type === 'reasoning.text' ? detail.text : detail?.type === 'reasoning.summary' ? detail.summary : '').filter(text => typeof text === 'string').join('');
+      if (reasoning.length > 0 || details.length > 0) {
+        if (!reasoningBlock) {
+          reasoningBlock = open('reasoning');
+          yield { type: 'block-start', index: reasoningBlock.index, blockType: 'reasoning' };
+        }
+        reasoningBlock.details.push(...details);
+        if (reasoning.length > 0) {
+          reasoningBlock.text += reasoning;
+          yield { type: 'reasoning-delta', index: reasoningBlock.index, text: reasoning };
+        }
+      }
+      if (typeof delta.content === 'string' && delta.content.length > 0) {
+        if (!textBlock) {
+          textBlock = open('text');
+          yield { type: 'block-start', index: textBlock.index, blockType: 'text' };
+        }
+        textBlock.text += delta.content;
+        yield { type: 'text-delta', index: textBlock.index, text: delta.content };
+      }
+      for (const call of Array.isArray(delta.tool_calls) ? delta.tool_calls : []) {
+        const key = call.index ?? call.id;
+        let block = tools.get(key);
+        if (!block) {
+          block = open('tool-call');
+          tools.set(key, block);
+          yield { type: 'block-start', index: block.index, blockType: 'tool-call' };
+        }
+        // id and name arrive once; an empty or null repeat is no update.
+        if (typeof call.id === 'string' && call.id.length > 0) block.callId = call.id;
+        if (typeof call.function?.name === 'string' && call.function.name.length > 0) 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: block.callId ?? '', ...(block.name !== undefined ? { name: block.name } : {}), argumentsDelta: fragment };
+      }
+      if (typeof choice.finish_reason === 'string') finish = choice.finish_reason;
+    }
+    if (chunk?.usage) {
+      usage = mapUsage(chunk.usage) ?? usage;
+      if (Number.isFinite(chunk.usage.cost) && chunk.usage.cost >= 0) cost = chunk.usage.cost;
+    }
+  }
+  throw new LlmError(`${label} stream ended without [DONE]`, 'TRANSPORT');
+}

package/plugins/providers/desktop-client.mjs

@@ -0,0 +1,84 @@
+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' };
+    function Accounts({ execute }) {
+      const [state, setState] = useState(null), [key, setKey] = useState(''), [busy, setBusy] = useState(false);
+      const [error, setError] = useState(''), [notice, setNotice] = useState(''), [confirm, setConfirm] = useState(null);
+      const [refreshError, setRefreshError] = useState('');
+      const pending = useRef(null), foreground = useRef(false), alive = useRef(true);
+      const run = async (action, args = {}, background = false) => {
+        if (background ? pending.current : foreground.current) return;
+        if (!background) { foreground.current = true; setBusy(true); setError(''); }
+        const previous = pending.current;
+        const operation = (async () => {
+          if (previous) await previous;
+          if (!alive.current) return;
+          try {
+            const value = await execute(action, args);
+            if (!alive.current) return;
+            setState(value); setRefreshError('');
+            if (action === 'status' && !value.opencode.pending) setNotice('');
+            if (action !== 'status') { setNotice(value.notice ?? ''); setConfirm(null); }
+            if (action === 'save-openrouter' || action === 'remove-openrouter') setKey('');
+          } catch (error) {
+            if (alive.current) {
+              if (background) setRefreshError(`Unable to refresh accounts: ${error.message}`);
+              else setError(error.message);
+            }
+          }
+        })();
+        pending.current = operation;
+        try { await operation; } finally {
+          if (pending.current === operation) pending.current = null;
+          if (!background) { foreground.current = false; if (alive.current) setBusy(false); }
+        }
+      };
+      useEffect(() => { alive.current = true; void run('status'); return () => { alive.current = false; }; }, []);
+      useEffect(() => {
+        if (!state?.opencode.pending) return;
+        const timer = setInterval(() => { void run('status', {}, true); }, 2000);
+        return () => clearInterval(timer);
+      }, [state?.opencode.pending]);
+      const button = (text, action, disabled = false) => h('button', { type: 'button', style: control, disabled: busy || disabled, onClick: action }, text);
+      const destructive = (id, label) => button(confirm === id ? `Confirm ${label.toLowerCase()}` : label, () => confirm === id ? run(id) : setConfirm(id));
+      return h('section', { 'aria-label': 'DSCODE account settings', style: { padding: 20, display: 'grid', gap: 16, maxWidth: 720 } },
+        h('h2', { style: { margin: 0 } }, 'DSCODE accounts'),
+        error && h('div', { role: 'alert' }, error),
+        refreshError && h('div', { role: 'alert' }, refreshError),
+        notice && h('div', { role: 'status', style: { whiteSpace: 'pre-wrap' } }, notice),
+        button('Refresh account status', () => run('status')),
+        state && h('fieldset', { disabled: busy, style: { border: '1px solid #8886', borderRadius: 8, padding: 16 } },
+          h('legend', null, 'DSCODE OpenRouter'),
+          h('p', null, state.openrouter.configured ? `Configured (${state.openrouter.source ?? 'saved'})` : 'No API key saved'),
+          h('p', null, 'The key is shared with DSCODE terminal sessions and native routes using the same credential. Select DSCODE OpenRouter in the model picker for DSCODE reasoning controls.'),
+          h('label', null, 'OpenRouter API key', h('input', { 'aria-label': 'OpenRouter API key', type: 'password', autoComplete: 'new-password', style: { ...control, display: 'block', width: '100%', boxSizing: 'border-box' },
+            value: key, disabled: !state.openrouter.writable, onChange: event => { setKey(event.target.value); setConfirm(null); } })),
+          h('div', { style: { display: 'flex', gap: 8, marginTop: 12 } },
+            button('Save OpenRouter key', () => run('save-openrouter', { key }), !state.openrouter.writable || !key.trim()),
+            state.openrouter.configured && state.openrouter.writable && destructive('remove-openrouter', 'Remove OpenRouter key'))),
+        state && h('fieldset', { disabled: busy, style: { border: '1px solid #8886', borderRadius: 8, padding: 16 } },
+          h('legend', null, 'Grok'),
+          h('p', null, state.grok.configured ? 'Local Grok CLI login available' : 'No usable local Grok CLI login'),
+          h('p', null, 'Run grok login in a terminal, then refresh this status. DSCODE reads ~/.grok/auth.json without changing or refreshing its tokens.')),
+        state && h('fieldset', { disabled: busy, style: { border: '1px solid #8886', borderRadius: 8, padding: 16 } },
+          h('legend', null, 'OpenCode Go'),
+          h('p', { style: { whiteSpace: 'pre-wrap' } }, state.opencode.lines.join('\n')),
+          h('p', null, 'Sign in opens the OpenCode consent page in your browser. It identifies the OpenCode CLI client used for this login.'),
+          h('div', { style: { display: 'flex', gap: 8 } },
+            button('Sign in to OpenCode Go', () => run('login-opencode'), state.opencode.pending),
+            state.opencode.pending && button('Cancel OpenCode login', () => run('cancel-opencode')),
+            state.opencode.configured && destructive('logout-opencode', 'Sign out of OpenCode Go'))));
+    }
+    return { inject: ['slots', 'connection'], apply(ctx) {
+      ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'dscode-accounts', order: 12, label: () => 'DSCODE accounts',
+        inject: () => ({ execute: async (action, args = {}) => {
+          const response = await ctx.connection.rpc.call('/api', 'dscode-accounts', { action, ...args });
+          if (!response.ok) throw Error(response.error.message);
+          return response.value;
+        } }),
+      }, Accounts));
+    } };
+  },
+});