dsh-theone 0.3.9 → 0.3.13

package/dist/index.js

@@ -19,10 +19,26 @@ import { EDITABLE_SETTINGS_KEYS, RESTART_SETTINGS_KEYS } from "./settings-types.
 import { validateSettings } from "./settings.js";
 import { RESTART_CODE, WorkerRun } from "./run.js";
 import { buildBriefing, LINK_SIGNAL, relatedTopics } from "./linkage.js";
+import { PACKAGE_NAME, Updater } from "./update.js";
 function redactDescriptor(text) {
     return text.replace(/\bsk-[a-zA-Z0-9_-]{16,}|\bBearer\s+\S+/gi, '[REDACTED]')
         .replace(/((?:api[_ -]?key|password|密码|密钥)\s*[:=：]\s*)\S+/gi, '$1[REDACTED]');
 }
+/**
+ * Main chat's model entries besides plain "TheOne": "TheOne · <model>" still answers through TheOne,
+ * with that model doing the routing and the background work.
+ */
+const VIA = 'via:';
+export function viaModel(selection) { return `${VIA}${selection.provider}/${selection.model}`; }
+export function parseVia(id) {
+    if (!id?.startsWith(VIA))
+        return undefined;
+    const rest = id.slice(VIA.length);
+    const slash = rest.indexOf('/');
+    if (slash <= 0 || slash === rest.length - 1 || rest.slice(0, slash) === 'theone')
+        return undefined;
+    return { provider: rest.slice(0, slash), model: rest.slice(slash + 1) };
+}
 /** Gateway provider delegates each accepted input to its context's DSH worker. */
 class GatewayAdapter extends LlmAdapter {
     service;
@@ -31,15 +47,11 @@ class GatewayAdapter extends LlmAdapter {
         this.service = service;
     }
     providerInfo(provider) { return { id: provider, name: 'TheOne' }; }
-    async listModels(provider) {
-        // The entry accepts whatever the backing model accepts (e.g. images).
-        const info = await this.service.gatewayModelInfo(provider).catch(() => undefined);
-        return [{ provider, id: 'gateway', name: 'TheOne', inputModalities: [...(info?.inputModalities ?? ['text'])] }];
-    }
+    listModels(provider) { return this.service.gatewayModels(provider); }
     resolveModel(provider, model, signal) {
-        if (model !== 'gateway')
-            throw new Error('TheOne only exposes the gateway model');
-        return this.service.gatewayModelInfo(provider, signal);
+        if (model !== 'gateway' && !parseVia(model))
+            throw new Error('TheOne only exposes its gateway models');
+        return this.service.gatewayModelInfo(provider, signal, model);
     }
     providerRetryPolicy() { return resolveRetryPolicy({ mode: 'normal', maxRetries: 0 }, 'theone.retry'); }
     stream(options) { return this.service.answer(options); }
@@ -85,6 +97,28 @@ function reasonLabel(reason) {
 function settingsConfig(values) {
     return { ...values, workerProvider: values.workerProvider ?? undefined, workerModel: values.workerModel ?? undefined, contextsPath: values.contextsPath ?? undefined };
 }
+/**
+ * Switch an installed bundle off and on so DSH loads its new version. This disposes the running
+ * TheOne, so it runs after the current request has answered and outlives this instance.
+ */
+function reloadBundle(manager, bundle) {
+    setTimeout(() => {
+        void (async () => {
+            const off = await manager.setBundleEnabled(bundle, false);
+            if (off.application === 'failed' || off.application === 'cancelled')
+                return;
+            await manager.setBundleEnabled(bundle, true);
+        })().catch(error => console.warn('TheOne could not reload itself after updating; restart DSH to apply the update.', error));
+    }, 300);
+}
+function readOwnVersion() {
+    try {
+        return String(JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version ?? '0.0.0');
+    }
+    catch {
+        return '0.0.0';
+    }
+}
 function readDescriptors(path) {
     const value = JSON.parse(readFileSync(path, 'utf8'));
     if (!Array.isArray(value))
@@ -132,6 +166,9 @@ export default class TheOne extends Service {
     closing = new Map();
     /** A model the user picked in main chat's own model selector; it answers through the Workers. */
     pickedModel;
+    adapter;
+    /** Update checks and one-click install through DSH's plugin manager. */
+    updater;
     /** Sessions whose current step answers through TheOne; only these refuse to run tools themselves. */
     throughTheOne = new WeakMap();
     constructor(ctx, config) {
@@ -164,6 +201,18 @@ export default class TheOne extends Service {
         }
         descriptors ??= config.contextsPath ? readDescriptors(config.contextsPath) : [];
         this.gatewayDirectory = resolve(dirname(databasePath), 'gateway');
+        this.updater = new Updater(readOwnVersion(), () => {
+            // The profile's package.json records how this plugin was installed (GitHub, npm or a local path).
+            const dir = ctx.profileContext?.dir;
+            if (!dir)
+                return undefined;
+            try {
+                return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')).dependencies?.[PACKAGE_NAME];
+            }
+            catch {
+                return undefined;
+            }
+        });
         ctx.effect(() => async () => {
             try {
                 await Promise.all([...this.workers.values()].map(handle => handle.dispose()));
@@ -183,7 +232,7 @@ export default class TheOne extends Service {
             this.catalog.start();
         }
         this.registerCatalogChannel();
-        ctx.llm.registerAdapter(['theone'], new GatewayAdapter(this));
+        this.adapter = ctx.llm.registerAdapter(['theone'], new GatewayAdapter(this));
         ctx.on('session/event', (session, event) => {
             if (event.type === 'turn/end') {
                 if (session.id === this.reservedGateway)
@@ -264,8 +313,8 @@ export default class TheOne extends Service {
                 return config;
             }
             this.throughTheOne.set(payload.agent, true);
-            // The resolved selection is authoritative; TheOne itself means "follow DSH's selected model".
-            this.pickedModel = config.provider === 'theone' ? undefined : { provider: config.provider, model: config.model };
+            // The resolved selection is authoritative; plain TheOne means "follow DSH's selected model".
+            this.pickedModel = config.provider === 'theone' ? parseVia(config.model) : { provider: config.provider, model: config.model };
             return config.provider === 'theone' ? config : { ...config, provider: 'theone', model: 'gateway' };
         }, { prepend: true });
         ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
@@ -278,7 +327,7 @@ export default class TheOne extends Service {
             // Know main chat's model choice before routing, so this very message is classified with it.
             const pickedNow = selected?.signal === signal ? selected.model : undefined;
             if (provider === 'theone')
-                this.pickedModel = undefined;
+                this.pickedModel = parseVia(pickedNow ?? agent.options.model);
             else if (provider && pickedNow)
                 this.pickedModel = { provider, model: pickedNow };
             const users = decision.messages.filter(message => message.source.kind === 'user');
@@ -566,6 +615,18 @@ export default class TheOne extends Service {
                         return Response.json({ error: code }, { status: code === 'GATEWAY_BUSY' ? 409 : 400 });
                     }
                 } }));
+            // Is a newer TheOne out, and install it with DSH's plugin manager (it loads after a restart).
+            child.effect(() => connection.fetch.register({ path: '/api/theone/update', methods: ['GET', 'POST'], requestBody: 'buffered', fetch: async (request) => {
+                    if (request.method === 'POST' && (this.active || this.reservedGateway))
+                        return Response.json({ ...await this.updater.status(), error: 'GATEWAY_BUSY' }, { status: 409 });
+                    const manager = this.ctx.get('pluginManager');
+                    // With DSH's hot reload, switching the bundle off and on loads the new version without a DSH restart.
+                    const live = !!this.ctx.get('hmr') && typeof manager?.setBundleEnabled === 'function';
+                    const status = request.method === 'POST'
+                        ? await this.updater.install(manager, live ? bundle => reloadBundle(manager, bundle) : undefined)
+                        : await this.updater.status(new URL(request.url).searchParams.has('force'));
+                    return Response.json(status, { headers: { 'cache-control': 'no-store' } });
+                } }));
             child.effect(() => connection.fetch.register({ path: '/api/theone/sessions', methods: ['GET'], requestBody: 'buffered', fetch: async () => Response.json({ sessions: await this.attachableSessions() }, { headers: { 'cache-control': 'no-store' } }) }));
             // The user's corrections to topic linking always take precedence over what was learned.
             child.effect(() => connection.fetch.register({ path: '/api/theone/links', methods: ['POST'], requestBody: 'buffered', fetch: async (request) => {
@@ -701,7 +762,7 @@ export default class TheOne extends Service {
         const defaultSelection = this.ctx.agentDefaultModel.currentSelection();
         const selection = c.workerProvider && c.workerModel
             ? { provider: c.workerProvider, model: c.workerModel }
-            : defaultSelection.provider !== 'theone' ? defaultSelection : this.store.rememberedModel(c.gatewayKey);
+            : defaultSelection.provider !== 'theone' ? defaultSelection : parseVia(defaultSelection.model) ?? this.store.rememberedModel(c.gatewayKey);
         let model = selection ? { provider: selection.provider, model: selection.model } : null;
         let modelUnavailable = !model;
         if (selection) {
@@ -729,10 +790,7 @@ export default class TheOne extends Service {
                 savedValues = validateSettings(saved.values, { contextsPath: c.contextsPath ?? null });
         }
         catch { /* Keep the current usable form. */ }
-        // A provider that cannot list its models in time offers none here.
-        const listed = await Promise.all(this.ctx.llm.listProviders().filter(provider => provider.id !== 'theone').map(provider => Promise.race([this.ctx.llm.listModels(provider.id), new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000).unref())])
-            .then(models => models.map(model => ({ provider: provider.id, id: model.id, name: model.name })), () => [])));
-        const models = listed.flat();
+        const models = (await this.offeredModels()).map(model => ({ provider: model.provider, id: model.id, name: model.name }));
         return { values, model, models, modelUnavailable, savedValues, revision: saved?.revision ?? 0,
             restartRequired: RESTART_SETTINGS_KEYS.some(key => savedValues[key] !== activeEditable[key]) };
     }
@@ -744,13 +802,21 @@ export default class TheOne extends Service {
         const { historyCatalog: _catalog, catalogIntervalMs: _interval, ...live } = settingsConfig(values);
         if (live.routerMode !== this.config.routerMode)
             this.router = this.routerFor(live.routerMode);
+        const modelChanged = live.workerProvider !== this.config.workerProvider || live.workerModel !== this.config.workerModel;
         this.config = { ...this.config, ...live };
+        // Main chat's reasoning levels and image input are the background model's; DSH re-reads them on this signal.
+        if (modelChanged)
+            try {
+                this.adapter?.replace(['theone']);
+            }
+            catch { /* Released during shutdown. */ }
         this.store.seed(descriptors);
     }
     /** Capture before Web saves the gateway itself as DSH's new default. */
     captureDefaultModel() {
-        const selection = this.ctx.agentDefaultModel.currentSelection();
-        if (selection.provider && selection.model && selection.provider !== 'theone')
+        const current = this.ctx.agentDefaultModel.currentSelection();
+        const selection = current.provider === 'theone' ? parseVia(current.model) : current;
+        if (selection?.provider && selection.model)
             this.store.rememberModel(this.config.gatewayKey, selection);
     }
     backingModel() {
@@ -764,12 +830,28 @@ export default class TheOne extends Service {
             throw new RouterFailure('ROUTER_MODEL_MISSING');
         return selection;
     }
-    /** The entry has exactly the configured backing model's capacity, including DSH overrides. */
-    async gatewayModelInfo(provider = 'theone', signal) {
-        const info = { provider, id: 'gateway', name: 'TheOne Gateway', inputModalities: ['text'] };
+    /** Every model DSH offers besides TheOne; a provider that cannot list its models in time offers none. */
+    async offeredModels() {
+        const listed = await Promise.all(this.ctx.llm.listProviders().filter(provider => provider.id !== 'theone').map(provider => Promise.race([this.ctx.llm.listModels(provider.id), new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000).unref())])
+            .catch(() => [])));
+        return listed.flat();
+    }
+    /**
+     * Main chat's model menu has one TheOne entry; the background model is chosen with the button
+     * beside it. Selections of the older "TheOne · <model>" entries still resolve.
+     */
+    async gatewayModels(provider) {
+        // The entry accepts whatever the backing model accepts (e.g. images).
+        const info = await this.gatewayModelInfo(provider).catch(() => undefined);
+        return [{ provider, id: 'gateway', name: 'TheOne', inputModalities: [...(info?.inputModalities ?? ['text'])] }];
+    }
+    /** The entry has exactly the backing model's capacity, including DSH overrides. */
+    async gatewayModelInfo(provider = 'theone', signal, model = 'gateway') {
+        const chosen = parseVia(model);
+        const info = { provider, id: model, name: 'TheOne Gateway', inputModalities: ['text'] };
         let selection;
         try {
-            selection = this.backingModel();
+            selection = chosen ?? this.backingModel();
         }
         catch (error) {
             if (error instanceof RouterFailure && error.code === 'ROUTER_MODEL_MISSING')
@@ -777,6 +859,8 @@ export default class TheOne extends Service {
             throw error;
         }
         const backing = await this.ctx.llm.resolveModelInfo(selection.provider, selection.model, signal);
+        if (chosen)
+            info.name = `TheOne · ${backing.name}`;
         // Image input and the thinking-effort choices are the backing model's, so main chat offers the same controls.
         return { ...info, ...(backing.inputModalities ? { inputModalities: [...backing.inputModalities] } : {}),
             ...(backing.reasoning ? { reasoning: backing.reasoning } : {}),

package/dist/update.d.ts

@@ -0,0 +1,55 @@
+export declare const REPOSITORY = "YunongDai2005/dsh-theone";
+export declare const PACKAGE_NAME = "dsh-theone";
+/** Where this copy was installed from, which decides where its updates come from. */
+export type UpdateSource = 'github' | 'npm' | 'other';
+export interface UpdateStatus {
+    current: string;
+    latest?: string;
+    /** A newer version exists. */
+    available: boolean;
+    /** It can be installed from here (otherwise reinstall by hand). */
+    installable: boolean;
+    source: UpdateSource;
+    /** installing → reloading (TheOne restarts itself; DSH keeps running), restart (applies after DSH restarts) or failed. */
+    state?: 'installing' | 'reloading' | 'restart' | 'failed';
+    error?: string;
+}
+/** The DSH plugin manager's install call, as TheOne uses it. */
+export interface PluginInstaller {
+    installBundle(spec: string, options?: {
+        enabled?: boolean;
+    }): Promise<{
+        application: string;
+        bundle?: string;
+        error?: {
+            code?: string;
+            message?: string;
+        } | unknown;
+    }>;
+}
+/** Compare dotted versions numerically; a pre-release sorts before its release. */
+export declare function compareVersions(a: string, b: string): number;
+/** Read the dependency spec DSH saved for this plugin: GitHub, npm, or something else (a local path, a tarball). */
+export declare function installSource(spec: string | undefined): UpdateSource;
+/** Checks for a newer TheOne and installs it through DSH's own plugin manager. */
+export declare class Updater {
+    readonly current: string;
+    private readonly spec;
+    private readonly fetcher;
+    private readonly now;
+    private checked?;
+    private state?;
+    private error?;
+    private pending?;
+    constructor(current: string, spec: () => string | undefined, fetcher?: typeof fetch, now?: () => number);
+    get source(): UpdateSource;
+    /** The latest known status; checks again at most every six hours (or now, when forced). */
+    status(force?: boolean): Promise<UpdateStatus>;
+    /**
+     * Install the newer version. With `reload`, TheOne then restarts itself so the new version runs
+     * without restarting DSH; otherwise it is loaded the next time DSH starts.
+     */
+    install(installer: PluginInstaller | undefined, reload?: (bundle: string) => void): Promise<UpdateStatus>;
+    private snapshot;
+    private check;
+}

package/dist/update.js

@@ -0,0 +1,121 @@
+export const REPOSITORY = 'YunongDai2005/dsh-theone';
+export const PACKAGE_NAME = 'dsh-theone';
+/** Compare dotted versions numerically; a pre-release sorts before its release. */
+export function compareVersions(a, b) {
+    const parse = (value) => {
+        const [core, pre] = value.trim().replace(/^v/, '').split('-', 2);
+        return { parts: core.split('.').map(part => Number.parseInt(part, 10) || 0), pre };
+    };
+    const x = parse(a), y = parse(b);
+    for (let index = 0; index < Math.max(x.parts.length, y.parts.length); index++) {
+        const difference = (x.parts[index] ?? 0) - (y.parts[index] ?? 0);
+        if (difference)
+            return Math.sign(difference);
+    }
+    if (x.pre === y.pre)
+        return 0;
+    return x.pre === undefined ? 1 : y.pre === undefined ? -1 : x.pre < y.pre ? -1 : 1;
+}
+/** Read the dependency spec DSH saved for this plugin: GitHub, npm, or something else (a local path, a tarball). */
+export function installSource(spec) {
+    if (!spec)
+        return 'other';
+    if (spec.toLowerCase().includes(REPOSITORY.toLowerCase()))
+        return 'github';
+    if (/^(?:npm:dsh-theone@)?[\^~>=<\s]*\d|^latest$|^\*$/.test(spec))
+        return 'npm';
+    return 'other';
+}
+const HOUR = 3600000;
+/** Checks for a newer TheOne and installs it through DSH's own plugin manager. */
+export class Updater {
+    current;
+    spec;
+    fetcher;
+    now;
+    checked;
+    state;
+    error;
+    pending;
+    constructor(current, spec, fetcher = fetch, now = Date.now) {
+        this.current = current;
+        this.spec = spec;
+        this.fetcher = fetcher;
+        this.now = now;
+    }
+    get source() { return installSource(this.spec()); }
+    /** The latest known status; checks again at most every six hours (or now, when forced). */
+    async status(force = false) {
+        const age = this.checked ? this.now() - this.checked.at : Infinity;
+        if (this.state !== 'installing' && (force || age > (this.checked?.error ? HOUR / 2 : 6 * HOUR))) {
+            this.pending ??= this.check().finally(() => { this.pending = undefined; });
+            await this.pending;
+        }
+        return this.snapshot();
+    }
+    /**
+     * Install the newer version. With `reload`, TheOne then restarts itself so the new version runs
+     * without restarting DSH; otherwise it is loaded the next time DSH starts.
+     */
+    async install(installer, reload) {
+        const status = await this.status();
+        if (!status.available || !status.installable || !installer || this.state === 'installing' || this.state === 'reloading' || this.state === 'restart')
+            return this.snapshot();
+        const spec = this.source === 'github' ? `github:${REPOSITORY}#${this.checked.sha}` : `${PACKAGE_NAME}@${this.checked.latest}`;
+        this.state = 'installing';
+        this.error = undefined;
+        try {
+            const result = await installer.installBundle(spec, { enabled: true });
+            if (result.application === 'applied' || result.application === 'restart-required') {
+                this.state = reload ? 'reloading' : 'restart';
+                reload?.(result.bundle ?? PACKAGE_NAME);
+            }
+            else {
+                this.state = 'failed';
+                const error = result.error;
+                this.error = String(error?.code ?? error?.message ?? result.application).slice(0, 120);
+            }
+        }
+        catch (error) {
+            this.state = 'failed';
+            this.error = (error instanceof Error ? error.message : String(error)).slice(0, 120);
+        }
+        return this.snapshot();
+    }
+    snapshot() {
+        const latest = this.checked?.latest;
+        const source = this.source;
+        const available = !!latest && compareVersions(latest, this.current) > 0;
+        return { current: this.current, ...(latest ? { latest } : {}), available, source,
+            installable: available && (source === 'npm' || (source === 'github' && !!this.checked?.sha)),
+            ...(this.state ? { state: this.state } : {}), ...(this.error ?? this.checked?.error ? { error: this.error ?? this.checked?.error } : {}) };
+    }
+    async check() {
+        const signal = AbortSignal.timeout(10000);
+        try {
+            if (this.source === 'npm') {
+                const response = await this.fetcher(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal });
+                if (!response.ok)
+                    throw new Error(`npm ${response.status}`);
+                this.checked = { at: this.now(), latest: String((await response.json()).version ?? '') || undefined };
+                return;
+            }
+            // A GitHub install updates to the exact commit whose version was read.
+            const commit = await this.fetcher(`https://api.github.com/repos/${REPOSITORY}/commits/main`, { signal, headers: { accept: 'application/vnd.github.sha' } });
+            if (!commit.ok)
+                throw new Error(`GitHub ${commit.status}`);
+            const sha = (await commit.text()).trim();
+            if (!/^[0-9a-f]{40}$/.test(sha))
+                throw new Error('GitHub returned no commit');
+            const manifest = await this.fetcher(`https://raw.githubusercontent.com/${REPOSITORY}/${sha}/package.json`, { signal });
+            if (!manifest.ok)
+                throw new Error(`GitHub ${manifest.status}`);
+            const latest = String((await manifest.json()).version ?? '') || undefined;
+            this.checked = { at: this.now(), latest, sha };
+        }
+        catch (error) {
+            // Offline or rate-limited: keep what was known and try again later.
+            this.checked = { ...this.checked, at: this.now(), error: (error instanceof Error ? error.message : String(error)).slice(0, 120) };
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-theone",
-  "version": "0.3.9",
+  "version": "0.3.13",
   "private": false,
   "type": "module",
   "description": "Automatic context routing for DeepSeek Harness",