dsh-her 0.0.1 → 0.1.0

package/lib/dsh/body-launcher.js

@@ -0,0 +1,48 @@
+/**
+ * Start the body app when no body is connected: the development body (the
+ * repository's `body/` next to this package, built with `npm run build`
+ * there) when there is one, else the installed app (body-install.ts).
+ *
+ * The Electron binary is found through `node_modules/electron/path.txt`, not
+ * `require('electron')`: inside the DSH desktop app that require returns
+ * Electron's API instead of the binary path. The body is detached so it
+ * outlives DSH (she sleeps until DSH is back), and ELECTRON_RUN_AS_NODE is
+ * removed or the body would start as plain Node.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** The development body next to this package, if it is built. */
+export function findDevBody(packageRoot = fileURLToPath(new URL('../../', import.meta.url))) {
+    const bodyDir = join(packageRoot, 'body');
+    const pathFile = join(bodyDir, 'node_modules', 'electron', 'path.txt');
+    if (!existsSync(join(bodyDir, 'dist', 'main.cjs')))
+        return { missing: `${bodyDir}/dist（在 body/ 里运行 npm run build）` };
+    if (!existsSync(pathFile))
+        return { missing: `${pathFile}（在 body/ 里运行 npm install）` };
+    const binary = join(bodyDir, 'node_modules', 'electron', 'dist', readFileSync(pathFile, 'utf8').trim());
+    return { binary, args: [bodyDir], cwd: bodyDir };
+}
+/** A body that is running but not connected yet (still backing off) has its pid in `<home>/body.json`. */
+export function bodyRunning(home) {
+    try {
+        const { pid } = JSON.parse(readFileSync(join(home, 'body.json'), 'utf8'));
+        if (typeof pid !== 'number')
+            return false;
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM: alive, owned by someone else.
+        return error.code === 'EPERM';
+    }
+}
+export function launchBody(plan, env) {
+    const childEnv = { ...process.env, DSH_HER_URL: env.url, DSH_HER_TOKEN: env.token, DSH_HER_HOME: env.home };
+    delete childEnv.ELECTRON_RUN_AS_NODE;
+    const args = env.pack === '' ? plan.args : [...plan.args, '--pack', env.pack];
+    const child = spawn(plan.binary, args, { cwd: plan.cwd, env: childEnv, detached: true, stdio: 'ignore' });
+    child.unref();
+    return child.pid;
+}

package/lib/dsh/config.js

@@ -0,0 +1,27 @@
+import Schema from '@deepseek-ai/schemastery';
+import { DEFAULT_VOICE, SAMPLE_PERSONA } from "../core/index.js";
+export const Config = Schema.object({
+    home: Schema.string().default('~/.dsh-her').description('dsh-her home (characters, packs, voice models)'),
+    character: Schema.object({
+        id: Schema.string().default('sample').description('Character id (her session and memory are keyed by it)'),
+        name: Schema.string().default('小禾').description('Her name'),
+        persona: Schema.string().role('textarea').default(SAMPLE_PERSONA).description('Who she is and how she talks'),
+    }).default({}),
+    provider: Schema.string().default('').description('Model provider for her session (empty = DSH default)'),
+    model: Schema.string().default('').description('Model for her session (empty = DSH default)'),
+    reasoningEffort: Schema.string().default('').description('Reasoning effort for her model (empty = route default; lower answers sooner)'),
+    port: Schema.natural().max(65535).default(38100).description('Preferred port for the body (next free one if taken)'),
+    body: Schema.object({
+        launch: Schema.union(['auto', 'off']).default('auto').description('Start the body app with DSH'),
+        pack: Schema.string().default('').description('Appearance pack directory (empty = body default)'),
+        releases: Schema.string().default('https://github.com/AIcivilization/dsh-her/releases/latest/download/').description('Where the body app is downloaded from (the folder with body-latest.json)'),
+        useDev: Schema.boolean().default(true).description('Use the development body in the repository when there is one (off: like a release install)'),
+    }).default({}),
+    voice: Schema.object({
+        enabled: Schema.boolean().default(true).description('Her voice; off = she only writes'),
+        voice: Schema.string().default(DEFAULT_VOICE).description('Her first voice: a Microsoft Edge voice (free, via edge-tts) or an Alibaba Cloud CosyVoice voice (key in DASHSCOPE_API_KEY or the macOS keychain); the "她" page can change it'),
+        speed: Schema.number().min(0.5).max(2).default(1).description('Speaking speed'),
+        threads: Schema.natural().min(1).max(16).default(4).description('CPU threads for local speech recognition'),
+        mic: Schema.union(['push-to-talk', 'always']).default('push-to-talk').description('Microphone: one utterance per shortcut press, or always listening'),
+    }).default({}),
+});

package/lib/dsh/her-session.js

@@ -0,0 +1,282 @@
+/**
+ * Her own session in DSH ("她 · <name>"): one ordinary persisted session per
+ * character. Created once, resumed after every restart; its id is kept under
+ * the dsh-her home, not in DSH. The creation follows dsh-vael's SelfSession.
+ *
+ * Inside her agent's scoped context she gets her own system prompt (DSH's
+ * coding-agent prompt and runtime chatter are replaced) and a listener on her
+ * live assistant stream, which turns text deltas into speakable sentences.
+ * Reasoning and tool-call deltas are never spoken.
+ *
+ * Her prompt is rebuilt at every model request, so its performance section
+ * always matches the body that is connected and what she remembers is current.
+ * Her tools: `play_action` (a longer performance by the body) and `remember`,
+ * `recall`, `forget` (her memory).
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildSystemPrompt, SentenceSplitter } from "../core/index.js";
+export class HerSession {
+    handle;
+    opening;
+    splitter = new SentenceSplitter();
+    /** Set by interrupt(): the rest of the current reply is not spoken. */
+    dropping = false;
+    /** The reply being streamed, unique across turns. */
+    replyId;
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get title() {
+        return `她 · ${this.deps.character().name}`;
+    }
+    get sessionId() {
+        return this.handle?.agent.session.id ?? this.recorded();
+    }
+    /** Her live agent: reuse, resume the recorded session, or create it the first time. */
+    ensure() {
+        if (this.handle !== undefined)
+            return Promise.resolve(this.handle);
+        this.opening ??= this.open().finally(() => { this.opening = undefined; });
+        return this.opening;
+    }
+    /** Send what you said (typed or recognized) as a new turn. */
+    async say(text, via) {
+        const { agent } = await this.ensure();
+        agent.followup({ id: randomUUID(), role: 'user', content: [{ type: 'text', text }], source: { kind: 'dsh-her', via } });
+        return agent;
+    }
+    /** Tell her something for her next turn without making her answer (what was heard of a cut-off reply, …). */
+    async note(text) {
+        const { agent } = await this.ensure();
+        agent.inject({ id: randomUUID(), role: 'user', content: [{ type: 'text', text }], source: { kind: 'dsh-her-context' } });
+    }
+    /** Stop the reply in progress (barge-in). DSH keeps the delivered prefix marked `interrupted`. */
+    interrupt() {
+        this.splitter.reset();
+        this.dropping = true;
+        try {
+            this.handle?.agent.cancel(new Error('dsh-her: interrupted'));
+        }
+        catch {
+            // nothing in progress
+        }
+    }
+    async dispose() {
+        const handle = this.handle;
+        this.handle = undefined;
+        try {
+            await handle?.dispose();
+        }
+        catch {
+            // the owning scope may already have torn it down
+        }
+    }
+    recordFile() {
+        return join(this.deps.dir, 'session.json');
+    }
+    recorded() {
+        try {
+            const value = JSON.parse(readFileSync(this.recordFile(), 'utf8'));
+            return typeof value.sessionId === 'string' ? value.sessionId : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async open() {
+        const services = this.deps.services();
+        if (services === undefined)
+            throw new Error('DSH 的 agents 服务还不可用');
+        const { logger, route } = this.deps;
+        const setup = (agentCtx) => this.composeScope(agentCtx);
+        const recorded = this.recorded();
+        if (recorded !== undefined) {
+            try {
+                this.handle = await services.agents.resume({ resumeSessionId: recorded, agentOptions: route, setup });
+                logger.info(`dsh-her: resumed ${this.title} (${recorded})`);
+                return this.handle;
+            }
+            catch (error) {
+                logger.warn(`dsh-her: could not resume ${recorded} (${error.message}); creating a new session`);
+            }
+        }
+        const sessionId = `dsh-her-${this.deps.cid}-${randomUUID()}`;
+        const room = join(this.deps.dir, 'room');
+        mkdirSync(room, { recursive: true });
+        const workspace = await services.workspaceRegistry?.create(room, this.title);
+        const handle = await services.agents.create({ sessionId, meta: { cwd: room }, agentOptions: route, setup });
+        try {
+            await workspace?.attachSession(sessionId);
+            services.sessionTitle?.rename(handle.agent.session, this.title);
+        }
+        catch (error) {
+            logger.warn(`dsh-her: session created but not attached/titled (${error.message})`);
+        }
+        writeFileSync(this.recordFile(), JSON.stringify({ sessionId, previous: recorded ?? null, createdAt: new Date().toISOString() }, null, 2));
+        logger.info(`dsh-her: created ${this.title} (${sessionId})`);
+        this.handle = handle;
+        return handle;
+    }
+    async composeScope(agentCtx) {
+        agentCtx.systemPrompt?.section({
+            name: 'dsh-her:system', order: 0, complete: true, interpolate: false,
+            // A failing part is left out, never the prompt: a throw here leaves her silent with no error (M4).
+            text: () => {
+                const { name, persona, callYou, pronoun } = this.deps.character();
+                return buildSystemPrompt({
+                    name, persona, you: { call: callYou, pronoun },
+                    performance: this.safe('performance', this.deps.performance), aboutYou: this.safe('aboutYou', this.deps.aboutYou), now: new Date(),
+                });
+            },
+        });
+        agentCtx.systemPrompt?.suppressRuntimeContext?.();
+        this.hideGlobalTools(agentCtx);
+        // Without her tools she can still talk; never let them keep her session closed.
+        await this.registerTools(agentCtx).catch((error) => this.deps.logger.warn(`dsh-her: play_action not registered (${error.message})`));
+        agentCtx.on('agent/assistant-stream', ({ frame }) => this.onFrame(frame));
+    }
+    /**
+     * Her tools, in DSH's native tool shape (plain JSON Schema). Not through
+     * `defineTool`: a plugin linked from outside the profile cannot import
+     * dsh-tools, and an unconverted schema makes the model provider reject the
+     * whole request.
+     */
+    safe(part, make) {
+        try {
+            return make();
+        }
+        catch (error) {
+            this.deps.logger.warn(`dsh-her: prompt part ${part} failed (${error.message})`);
+            return '';
+        }
+    }
+    async registerTools(agentCtx) {
+        const playAction = this.deps.playAction;
+        agentCtx.tools.register({
+            name: 'play_action',
+            description: '让你在桌面上的身体做一个较长的表演（离开画面换衣服、说准备好的台词等），做完才返回。能做哪些见系统提示词的"表演"一节。',
+            parameters: {
+                type: 'object',
+                properties: { action: { type: 'string', description: '表演的名字，比如 outfit_jk' } },
+                required: ['action'],
+                additionalProperties: false,
+            },
+            output: {
+                schema: { type: 'object', properties: { ok: { type: 'boolean' }, text: { type: 'string' } }, required: ['ok', 'text'] },
+                render: (_args, value) => [{ type: 'text', text: value.text }],
+            },
+            execute: async (args) => {
+                const action = String(args.action ?? '').trim();
+                const result = await playAction(action);
+                if (result.ok)
+                    return { ok: true, text: result.transcript === undefined ? `已经做完：${action}` : `已经做完：${action}（你说了"${result.transcript}"）` };
+                const why = { unsupported: '身体不会这个表演', interrupted: '做到一半被打断了', 'no body': '桌面上没有连着身体', timeout: '等了太久没做完' }[result.reason ?? ''] ?? result.reason ?? '没做成';
+                return { ok: false, text: `没做成：${action}（${why}）` };
+            },
+        });
+        const memory = this.deps.memory;
+        const textOutput = {
+            schema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] },
+            render: (_args, value) => [{ type: 'text', text: value.text }],
+        };
+        agentCtx.tools.register({
+            name: 'remember',
+            description: '记下一件关于对方的事。fact：长期成立的事实（称呼、喜好、忌讳、重要的人、生日）；event：具体的事，有日期就写 date。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    text: { type: 'string', description: '一句话，比如"他不吃香菜"、"他下周三去面试"' },
+                    kind: { type: 'string', enum: ['fact', 'event'] },
+                    date: { type: 'string', description: 'event 发生的日期 YYYY-MM-DD（把"明天""下周三"换算好）；没有就不填' },
+                },
+                required: ['text', 'kind'],
+                additionalProperties: false,
+            },
+            output: textOutput,
+            execute: async (args) => {
+                const hit = memory.remember({ kind: args.kind === 'event' ? 'episode' : 'fact', text: String(args.text ?? ''), ...(args.date === undefined ? {} : { due: args.date }) }, new Date());
+                return { text: `记下了（${hit.id}）：${hit.text}` };
+            },
+        });
+        agentCtx.tools.register({
+            name: 'recall',
+            description: '在你的记忆里找和这个话题有关的事（关于对方的事实、发生过的事、你的日记）。',
+            parameters: {
+                type: 'object',
+                properties: { query: { type: 'string', description: '要找的话题，比如"面试"、"猫"' } },
+                required: ['query'],
+                additionalProperties: false,
+            },
+            output: textOutput,
+            execute: async (args) => {
+                const hits = memory.recall(String(args.query ?? ''), new Date());
+                if (hits.length === 0)
+                    return { text: '没找到相关的记忆。' };
+                return { text: hits.map(h => `[${h.id}] ${h.at.slice(0, 10)} ${h.text}`).join('\n') };
+            },
+        });
+        agentCtx.tools.register({
+            name: 'forget',
+            description: '删掉记忆里的几条（id 来自 recall 的结果）。只在对方明确让你忘掉、并且确认过是哪条之后用。',
+            parameters: {
+                type: 'object',
+                properties: { ids: { type: 'array', items: { type: 'string' }, description: '要删的 id，比如 ["f3", "e2"]' } },
+                required: ['ids'],
+                additionalProperties: false,
+            },
+            output: textOutput,
+            execute: async (args) => {
+                const removed = memory.remove(Array.isArray(args.ids) ? args.ids.map(String) : []);
+                return { text: removed === 0 ? '没有删掉任何东西（id 不对？）' : `删掉了 ${removed} 条。` };
+            },
+        });
+    }
+    /**
+     * P1: she only keeps you company, so DSH's work tools (shell, files, web…)
+     * are hidden from her session. Their schemas would also cost thousands of
+     * tokens on every turn. Tools she gets later are registered in her own scope,
+     * which a restriction never hides.
+     */
+    hideGlobalTools(agentCtx) {
+        try {
+            const names = agentCtx.tools.schemas().map(schema => schema.name).filter(name => name !== 'run_code');
+            if (names.length > 0)
+                agentCtx.tools.restrict({ deny: names });
+        }
+        catch (error) {
+            this.deps.logger.warn(`dsh-her: could not hide DSH tools from her session (${error.message})`);
+        }
+    }
+    onFrame(frame) {
+        const { events } = this.deps;
+        if (frame.type === 'start') {
+            this.splitter.reset();
+            this.dropping = false;
+            // DSH's attempt id repeats across turns (it ends in the agent's revision), so the turn and step make it unique.
+            this.replyId = `${frame.attemptId}@${frame.turn}.${frame.step}`;
+            events.start(this.replyId);
+            return;
+        }
+        const id = this.replyId;
+        if (id === undefined)
+            return;
+        if (frame.type === 'chunk') {
+            if (this.dropping || frame.chunk.type !== 'text-delta' || typeof frame.chunk.text !== 'string')
+                return;
+            for (const sentence of this.splitter.push(frame.chunk.text))
+                events.sentence(id, sentence);
+        }
+        else {
+            if (!this.dropping && frame.outcome.kind !== 'abandoned') {
+                for (const sentence of this.splitter.flush())
+                    events.sentence(id, sentence);
+            }
+            this.splitter.reset();
+            this.replyId = undefined;
+            events.end(id, frame.outcome.kind);
+        }
+    }
+}

package/lib/dsh/import-status.js

@@ -0,0 +1,6 @@
+/**
+ * Where a pack import started from the "她" page stands. The import itself
+ * runs in the body (it reads your folder and has ffmpeg); the body reports
+ * progress and a report, which the page shows by polling the brain's state.
+ */
+export const IDLE_IMPORT = { state: 'idle', done: 0, total: 0, step: '', lines: [] };