@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/plugins/custom/index.mjs

@@ -0,0 +1,145 @@
+import z from '@deepseek-ai/schemastery';
+import { watchFile, unwatchFile } from 'node:fs';
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { createToolResultMessage, resolveImageAttachmentAccess } from '@deepseek-ai/dsh-llm';
+import { CustomStore, validateProfile, customId, keyRef, isCustomId } from './config.mjs';
+import { CustomAdapter, authHeaders } from './adapter.mjs';
+
+export const name = 'dscode-custom';
+export const inject = ['llm', 'credentials'];
+export const Config = z.object({ path: z.string().default('') });
+export const getCustomProviders = ctx => ctx.get('dscodeCustom');
+
+export class CustomProviders {
+  constructor({ store = new CustomStore(), credentials, resolveAttachments, resolveImageAccess, fetch = globalThis.fetch, changed = () => {} }) {
+    Object.assign(this, { store, credentials, fetch, changed });
+    this.providers = [];
+    this.adapter = new CustomAdapter({ profile: id => this.providers.find(p => p.id === id), resolveKey: p => this.resolveKey(p), resolveAttachments, resolveImageAccess, fetch });
+  }
+  async refresh() {
+    const snapshot = await this.store.read();
+    if (snapshot.revision !== this.revision) {
+      this.providers = snapshot.providers; this.revision = snapshot.revision; this.changed(this.providers);
+    }
+    return snapshot;
+  }
+  async list() {
+    const snapshot = await this.refresh();
+    return { ...snapshot, providers: await Promise.all(snapshot.providers.map(async p => {
+      const facts = await this.credentials.describe(credentialRef(keyRef(p.id)));
+      return { ...p, credentialStatus: p.auth === 'none' ? 'No authentication' : facts.configured ? facts.source === 'env' ? 'Key from environment' : 'Key saved' : 'API key missing' };
+    })) };
+  }
+  newProfile() { return { id: customId(), name: '', baseURL: '', api: 'chat-completions', auth: 'bearer', backend: 'generic', timeoutMs: 180000, models: [] }; }
+  async resolveKey(profile, draftKey) {
+    if (profile.auth === 'none') return undefined;
+    if (draftKey) return draftKey;
+    return (await this.credentials.resolve(credentialRef(keyRef(profile.id))))?.value;
+  }
+  async save(input, key, revision) {
+    const profile = validateProfile(input);
+    if (key && (/[\s\x00-\x1f]/.test(key) || key.length > 4096)) throw Error('Paste only the API key, without whitespace');
+    await this.store.update(revision, async providers => {
+      if (key) await this.credentials.set(credentialRef(keyRef(profile.id)), key);
+      return [...providers.filter(p => p.id !== profile.id), profile];
+    });
+    return this.list();
+  }
+  async remove(id, revision) {
+    if (!isCustomId(id)) throw Error('Invalid custom provider ID');
+    await this.store.update(revision, async providers => {
+      const ref = credentialRef(keyRef(id));
+      const facts = await this.credentials.describe(ref);
+      // Native credentials supplied by the environment are read-only. They
+      // cannot keep a deleted route alive or prevent removing its configuration.
+      if (facts.source !== 'env') await this.credentials.unset(ref);
+      return providers.filter(p => p.id !== id);
+    });
+    return this.list();
+  }
+  async clearKey(id) { await this.credentials.unset(credentialRef(keyRef(id))); }
+  async json(profile, path, key, signal) {
+    const response = await this.fetch(profile.baseURL + path, { redirect: 'error', headers: authHeaders(profile, key), signal: AbortSignal.any([AbortSignal.timeout(10000), ...(signal ? [signal] : [])]) });
+    if (!response.ok) { await response.body?.cancel(); throw Error(`Model discovery returned HTTP ${response.status}`); }
+    return response.json();
+  }
+  async discover(input, draftKey, signal) {
+    const profile = validateProfile(input), key = await this.resolveKey(profile, draftKey);
+    let listing;
+    try { listing = await this.json(profile, '/models', key, signal); }
+    // Transport exceptions can carry request headers; do not retain their cause.
+    // eslint-disable-next-line preserve-caught-error
+    catch (error) { if (signal?.aborted) throw Error('Discovery cancelled'); throw Error(error.message?.startsWith('Model discovery returned HTTP') ? error.message : 'Could not discover models; check the address and key, or add a model manually'); }
+    if (signal?.aborted) throw Error('Discovery cancelled');
+    if (!Array.isArray(listing.data)) throw Error('Model listing has no data array; enter a model manually');
+    const backend = listing.data.some(m => m.owned_by === 'omlx') ? 'omlx' : 'generic';
+    let status = [];
+    if (backend === 'omlx') {
+      try {
+        const metadata = await this.json(profile, '/models/status', key, signal);
+        if (Array.isArray(metadata?.models)) status = metadata.models;
+      } catch { /* Optional oMLX metadata; the standard listing still works. */ }
+      if (signal?.aborted) throw Error('Discovery cancelled');
+    }
+    const positive = value => Number.isSafeInteger(value) && value > 0;
+    const models = [];
+    for (const entry of listing.data) {
+      if (typeof entry.id !== 'string' || !entry.id.trim() || models.some(m => m.id === entry.id)) continue;
+      const detail = status.find(m => m?.id === entry.id);
+      const contextWindow = [detail?.max_context_window, entry.max_model_len, entry.context_length, entry.context_window].find(positive);
+      const maxTokens = [detail?.max_tokens, entry.max_output_tokens].find(value => positive(value) && (!contextWindow || value < contextWindow));
+      models.push({ id: entry.id, name: entry.name ?? entry.id, thinking: 'default',
+        ...(positive(contextWindow) ? { contextWindow, contextSource: 'server' } : {}),
+        ...(positive(maxTokens) && (!positive(contextWindow) || maxTokens < contextWindow) ? { maxTokens, outputSource: 'server' } : {}) });
+    }
+    return { backend, models };
+  }
+  /** Probe only this draft, without registering it or touching files. */
+  async test(input, modelId, draftKey, signal) {
+    const profile = validateProfile(input), model = profile.models.find(m => m.id === modelId);
+    if (!model?.contextWindow) throw Error('Fill in the model context window before testing');
+    const adapter = new CustomAdapter({ profile: () => profile, resolveKey: p => this.resolveKey(p, draftKey), fetch: this.fetch });
+    const stages = [];
+    const call = async (messages, tools) => {
+      const chunks = [];
+      for await (const chunk of adapter.stream({ provider: profile.id, model: model.id, messages, tools, maxTokens: 512, ...(profile.backend === 'omlx' ? { reasoningEffort: 'off' } : {}), signal })) chunks.push(chunk);
+      const finish = chunks.find(c => c.type === 'finish');
+      if (!finish || !['stop', 'tool-calls'].includes(finish.reason.kind)) throw Error('Probe did not complete normally');
+      return { blocks: chunks.filter(c => c.type === 'block-end').map(c => c.block), replayState: finish.replayState };
+    };
+    try {
+      const plain = await call([{ role: 'user', content: [{ type: 'text', text: 'Reply with exactly CUSTOM_OK.' }] }]);
+      if (!plain.blocks.some(b => b.type === 'text' && b.text.trim() === 'CUSTOM_OK')) throw Error('Text probe returned an unexpected answer');
+      stages.push({ name: 'Text and streaming', status: 'passed' });
+      const tools = [{ name: 'lookup_probe', description: 'Look up a test value.', parameters: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'], additionalProperties: false } }];
+      const messages = [{ role: 'user', content: [{ type: 'text', text: 'Call lookup_probe with name studio. After the tool returns, reply with exactly its value.' }] }];
+      const first = await call(messages, tools);
+      const calls = first.blocks.filter(b => b.type === 'tool-call');
+      if (calls.length !== 1 || calls[0].name !== 'lookup_probe' || JSON.parse(calls[0].arguments).name !== 'studio') throw Error('Tool probe returned an unexpected call');
+      stages.push({ name: 'Streamed tool arguments', status: 'passed' });
+      messages.push({ role: 'assistant', source: { provider: profile.id, model: model.id, replayState: first.replayState }, content: first.blocks });
+      messages.push(createToolResultMessage({ callId: calls[0].id, content: [{ type: 'text', text: '{"value":"CUSTOM_TOOL_OK"}' }], isError: false }));
+      const second = await call(messages, tools);
+      if (second.blocks.some(b => b.type === 'tool-call') || !second.blocks.some(b => b.type === 'text' && b.text.trim() === 'CUSTOM_TOOL_OK')) throw Error('Tool result replay returned an unexpected answer');
+      stages.push({ name: 'Tool result round trip', status: 'passed' }, { name: 'Images, thinking and long context', status: 'not tested' });
+    } catch (error) { stages.push({ name: 'Probe', status: 'failed', message: signal?.aborted ? 'Cancelled' : error.message }); }
+    return stages;
+  }
+}
+
+export async function apply(ctx, config = {}) {
+  let registration;
+  const service = new CustomProviders({ store: new CustomStore(config.path || undefined), credentials: ctx.credentials,
+    resolveAttachments: () => ctx.get('attachments'),
+    resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, hostPath => ctx.get('fs')?.processPathFromHostPath(hostPath), ref),
+    changed: profiles => {
+    const ids = profiles.map(p => p.id);
+    if (registration) registration.replace(ids);
+    else if (ids.length) registration = ctx.llm.registerAdapter(ids, service.adapter);
+  } });
+  ctx.provide('dscodeCustom', service);
+  try { await service.refresh(); } catch { ctx.logger.warn('Could not read custom providers; repair ~/.dscode/providers.yaml'); }
+  const refresh = () => { void service.refresh().catch(() => ctx.logger.warn('Invalid custom provider edit; retaining the last valid configuration')); };
+  watchFile(service.store.path, { persistent: false, interval: 1000 }, refresh);
+  ctx.effect(() => () => unwatchFile(service.store.path, refresh));
+}

package/plugins/custom/wire.mjs

@@ -0,0 +1,179 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { serializeMessages } from '../providers/chat-messages.mjs';
+import { errorCode } from '../providers/http-errors.mjs';
+
+export const REPLAY_KIND = 'dscode-custom';
+const textOf = blocks => blocks.filter(b => b.type === 'text').map(b => b.text).join('');
+const toolDefinitions = options => (options.tools ?? []).map(t => ({ name: t.name, description: t.description, parameters: t.parameters }));
+function nativeReasoning(message, profile, model) {
+  const source = message.source, replay = source?.replayState?.response;
+  return source?.provider === profile.id && source.model === model && replay?.kind === REPLAY_KIND && replay.api === profile.api
+    ? replay.nativeReasoning ?? [] : [];
+}
+
+export function requestBody(profile, model, options, images) {
+  const budget = options.maxTokens ?? model.maxTokens ?? Math.min(4096, Math.floor(model.contextWindow / 4));
+  const temperature = options.temperature === undefined ? {} : { temperature: options.temperature };
+  const tools = toolDefinitions(options);
+  const serialization = { model: model.id, images, dialect: { provider: profile.id, reasoningContent: () => false } };
+  const effort = options.reasoningEffort;
+  const thinking = effort === 'off' ? false : effort === 'high' ? true : model.thinking === 'off' ? false : model.thinking === 'on' ? true : undefined;
+  if (effort !== undefined && !(profile.backend === 'omlx' && ['off', 'high'].includes(effort))) throw new LlmError('This custom model does not advertise that reasoning effort', 'UNSUPPORTED_REASONING_EFFORT');
+  if (thinking !== undefined && profile.backend !== 'omlx') throw new LlmError('Thinking overrides currently require an identified oMLX service; use Server default', 'INVALID_REQUEST');
+  const extra = thinking === undefined ? {} : profile.api === 'chat-completions' ? { enable_thinking: thinking } : { chat_template_kwargs: { enable_thinking: thinking } };
+  const common = { model: model.id, stream: true, ...temperature, ...extra };
+  if (profile.api === 'chat-completions') return { ...common,
+    messages: serializeMessages(options.messages, { ...serialization, system: options.system }),
+    max_tokens: budget, stream_options: { include_usage: true }, ...(tools.length ? { tools: tools.map(f => ({ type: 'function', function: f })) } : {}), ...(options.stop ? { stop: options.stop } : {}) };
+
+  // Stateless replay: the local session remains authoritative, including native
+  // reasoning items/signatures when the same endpoint protocol produced them.
+  const input = [], anthropic = [];
+  const system = [options.system, ...options.messages.filter(m => m.role === 'system').map(m => textOf(m.content))].filter(Boolean).join('\n\n');
+  for (const message of options.messages.filter(m => m.role !== 'system')) {
+    const native = nativeReasoning(message, profile, model.id);
+    if (profile.api === 'responses') input.push(...native);
+    const parts = [];
+    if (profile.api === 'anthropic' && message.role === 'assistant') parts.push(...native);
+    for (const wire of serializeMessages([message], serialization)) {
+      if (wire.role === 'tool') {
+        input.push({ type: 'function_call_output', call_id: wire.tool_call_id, output: wire.content });
+        parts.push({ type: 'tool_result', tool_use_id: wire.tool_call_id, content: wire.content,
+          ...(message.role === 'tool' && message.isError ? { is_error: true } : {}) });
+      } else {
+        if (wire.content) {
+          const content = typeof wire.content === 'string' ? [{ type: 'text', text: wire.content }] : wire.content;
+          if (profile.api === 'responses') input.push({ role: wire.role, content: content.map(part => part.type === 'text'
+            ? { type: wire.role === 'assistant' ? 'output_text' : 'input_text', text: part.text }
+            : { type: 'input_image', image_url: part.image_url.url, detail: 'auto' }) });
+          else for (const part of content) {
+            if (part.type === 'text') parts.push(part);
+            else {
+              // The shared serializer creates data URLs from prepared attachment bytes.
+              const [, mediaType, data] = /^data:([^;]+);base64,(.*)$/.exec(part.image_url.url);
+              parts.push({ type: 'image', source: { type: 'base64', media_type: mediaType, data } });
+            }
+          }
+        }
+        for (const call of wire.tool_calls ?? []) {
+          input.push({ type: 'function_call', call_id: call.id, name: call.function.name, arguments: call.function.arguments });
+          let args;
+          try { args = JSON.parse(call.function.arguments); } catch { throw new LlmError('Cannot replay invalid tool arguments', 'INVALID_REQUEST'); }
+          parts.push({ type: 'tool_use', id: call.id, name: call.function.name, input: args });
+        }
+      }
+    }
+    if (parts.length) {
+      const role = message.role === 'assistant' ? 'assistant' : 'user';
+      if (anthropic.at(-1)?.role === role) anthropic.at(-1).content.push(...parts);
+      else anthropic.push({ role, content: parts });
+    }
+  }
+  if (profile.api === 'responses') return { ...common, input, ...(system ? { instructions: system } : {}), max_output_tokens: budget, store: false, include: ['reasoning.encrypted_content'], ...(tools.length ? { tools: tools.map(t => ({ type: 'function', ...t })) } : {}) };
+  // Native parallel tool results arrive as separate messages. After merging
+  // their user turns, all results must precede accompanying text and screenshots.
+  for (const message of anthropic) if (message.role === 'user') {
+    message.content = [...message.content.filter(p => p.type === 'tool_result'), ...message.content.filter(p => p.type !== 'tool_result')];
+  }
+  return { ...common, messages: anthropic, ...(system ? { system } : {}), max_tokens: budget, ...(tools.length ? { tools: tools.map(t => ({ name: t.name, description: t.description, input_schema: t.parameters })) } : {}), ...(options.stop ? { stop_sequences: options.stop } : {}) };
+}
+
+const delta = (value, extra = {}) => JSON.stringify({ choices: [{ index: 0, delta: value }], ...extra });
+const toolDelta = (index, id, name, args = '') => delta({ tool_calls: [{ index, ...(id ? { id } : {}), function: { ...(name ? { name } : {}), arguments: args } }] });
+function responseUsage(u) {
+  return u && { prompt_tokens: u.input_tokens, completion_tokens: u.output_tokens, prompt_tokens_details: { cached_tokens: u.input_tokens_details?.cached_tokens ?? 0 }, completion_tokens_details: { reasoning_tokens: u.output_tokens_details?.reasoning_tokens ?? 0 } };
+}
+function anthropicUsage(u) {
+  return { prompt_tokens: (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0), completion_tokens: u.output_tokens ?? 0,
+    prompt_tokens_details: { cached_tokens: u.cache_read_input_tokens ?? 0, cache_write_tokens: u.cache_creation_input_tokens ?? 0 } };
+}
+
+/** Normalize the two event protocols to the shared chat stream assembler. */
+export async function* normalizedEvents(payloads, api, replay) {
+  if (api === 'chat-completions') { yield* payloads; return; }
+  let usage = {}, finish = 'stop';
+  const blocks = new Map(), emitted = new Set(), native = new Map();
+  for await (const raw of payloads) {
+    if (raw === '[DONE]') continue;
+    let event;
+    try { event = JSON.parse(raw); } catch { throw new LlmError('Malformed custom API stream event', 'MALFORMED_RESPONSE'); }
+    if (event.error || event.type === 'error' || event.type === 'response.failed') {
+      const error = event.error ?? event.response?.error;
+      throw new LlmError('Custom API returned an error during streaming', errorCode(undefined, { ...error, metadata: { error_type: error?.code ?? error?.type } }));
+    }
+    if (event.type === 'response.refusal.delta') throw new LlmError('Custom model declined this request', 'CONTENT_FILTER');
+    if (api === 'responses') {
+      const i = event.output_index ?? 0;
+      if (event.type === 'response.output_item.added') {
+        blocks.set(i, event.item);
+        if (event.item?.type === 'function_call') yield toolDelta(i, event.item.call_id, event.item.name);
+      } else if (event.type === 'response.output_text.delta') {
+        emitted.add(`text:${i}`); yield delta({ content: event.delta });
+      } else if (event.type === 'response.reasoning_summary_text.delta' || event.type === 'response.reasoning_text.delta') {
+        emitted.add(`reasoning:${i}`); yield delta({ reasoning_content: event.delta });
+      } else if (event.type === 'response.function_call_arguments.delta') {
+        emitted.add(`args:${i}`); yield toolDelta(i, undefined, undefined, event.delta);
+      } else if (event.type === 'response.output_item.done') {
+        blocks.set(i, event.item);
+        if (event.item?.type === 'reasoning') native.set(i, event.item);
+      }
+      if (['response.completed', 'response.incomplete'].includes(event.type)) {
+        const response = event.response;
+        if (!response || response.status === 'failed') throw new LlmError('Custom response failed', 'TRANSPORT');
+        const items = response.output ?? [...blocks.values()];
+        for (const [index, item] of items.entries()) {
+          if (item.type === 'function_call' && !emitted.has(`args:${index}`)) yield toolDelta(index, item.call_id, item.name, item.arguments ?? '{}');
+          if (item.type === 'message' && !emitted.has(`text:${index}`)) {
+            const text = (item.content ?? []).map(b => b.text ?? '').join('');
+            if (text) yield delta({ content: text });
+          }
+          if (item.type === 'reasoning') {
+            native.set(index, item);
+            if (!emitted.has(`reasoning:${index}`)) {
+              const text = (item.summary ?? []).map(b => b.text ?? '').join('');
+              if (text) yield delta({ reasoning_content: text });
+            }
+          }
+        }
+        replay.nativeReasoning = [...native.values()];
+        const incomplete = response.incomplete_details?.reason;
+        finish = event.type === 'response.incomplete' ? incomplete === 'max_output_tokens' ? 'length' : 'content_filter' : 'stop';
+        yield JSON.stringify({ id: response.id, choices: [{ delta: {}, finish_reason: finish }], usage: responseUsage(response.usage) });
+        yield '[DONE]'; return;
+      }
+    } else {
+      if (event.type === 'message_start') { usage = { ...event.message?.usage }; yield delta({}, { id: event.message?.id }); }
+      if (event.type === 'content_block_start') {
+        const b = { ...event.content_block }; blocks.set(event.index, b);
+        if (b.type === 'tool_use') yield toolDelta(event.index, b.id, b.name);
+        if (b.type === 'text' && b.text) yield delta({ content: b.text });
+        if (b.type === 'thinking' || b.type === 'redacted_thinking') {
+          native.set(event.index, b);
+          if (b.thinking) yield delta({ reasoning_content: b.thinking });
+        }
+      }
+      if (event.type === 'content_block_delta') {
+        const d = event.delta, b = blocks.get(event.index);
+        if (d.type === 'text_delta') yield delta({ content: d.text });
+        if (d.type === 'input_json_delta') { emitted.add(`args:${event.index}`); yield toolDelta(event.index, undefined, undefined, d.partial_json); }
+        if (d.type === 'thinking_delta') { if (b) b.thinking = (b.thinking ?? '') + d.thinking; yield delta({ reasoning_content: d.thinking }); }
+        if (d.type === 'signature_delta' && b) b.signature = (b.signature ?? '') + d.signature;
+      }
+      if (event.type === 'content_block_stop') {
+        const b = blocks.get(event.index);
+        if (b?.type === 'tool_use' && !emitted.has(`args:${event.index}`)) yield toolDelta(event.index, undefined, undefined, JSON.stringify(b.input ?? {}));
+      }
+      if (event.type === 'message_delta') {
+        usage = { ...usage, ...event.usage };
+        const reason = event.delta?.stop_reason;
+        finish = reason === 'max_tokens' ? 'length' : reason === 'tool_use' ? 'tool_calls' : ['end_turn', 'stop_sequence', null, undefined].includes(reason) ? 'stop' : reason;
+      }
+      if (event.type === 'message_stop') {
+        replay.nativeReasoning = [...native.values()];
+        yield JSON.stringify({ choices: [{ delta: {}, finish_reason: finish }], usage: anthropicUsage(usage) });
+        yield '[DONE]'; return;
+      }
+    }
+  }
+  throw new LlmError('Custom API stream ended before its terminal event', 'TRANSPORT');
+}