@minko-ai/minko 0.1.0 → 0.1.1

package/dist/agent/workers.js

@@ -0,0 +1,503 @@
+import { runAgent } from "./loop.js";
+import { ALL_TOOLS } from "../tools/registry.js";
+import { WorkerStore } from "./workerStore.js";
+const WORKER_SYSTEM = [
+    '你是 Minko 的后台只读 worker。',
+    '只做被委派的调查，使用 read_file / list_dir / search_files / retrieve_context 等只读工具。',
+    '不要修改文件、不要执行命令、不要向用户提问。',
+    '完成后给出简明结论；不确定的地方如实说明。',
+].join('\n');
+/**
+ * In-process background workers. Each one is an independent, read-only agent
+ * with its own context, bounded concurrency and a timeout.
+ */
+export class WorkerRegistry {
+    options;
+    workers = new Map();
+    queue = [];
+    running = 0;
+    runningWritable = false;
+    sequence = 0;
+    store;
+    constructor(options) {
+        this.options = {
+            getProvider: options.getProvider,
+            getConfig: options.getConfig,
+            cwd: options.cwd,
+            maxConcurrent: options.maxConcurrent ?? 2,
+            timeoutMs: options.timeoutMs ?? 300_000,
+            maxOutputChars: options.maxOutputChars ?? 8_000,
+            maxWorkers: options.maxWorkers ?? 50,
+            approve: options.approve,
+            approvalStore: options.approvalStore,
+        };
+        this.store = options.store ?? new WorkerStore(options.storeDir);
+        this.store.markStale();
+    }
+    getStore() {
+        return this.store;
+    }
+    create(input) {
+        const prompt = input.prompt.trim();
+        if (prompt.length === 0) {
+            throw new Error('缺少 prompt 参数');
+        }
+        this.sequence += 1;
+        const id = 'w-' + Date.now().toString(36) + '-' + this.sequence.toString(36);
+        let resolveDone = () => { };
+        const done = new Promise((resolve) => { resolveDone = resolve; });
+        const cwd = input.cwd?.trim();
+        const worker = {
+            id,
+            name: input.name?.trim() || 'worker-' + this.sequence,
+            prompt,
+            team: input.team?.trim() || undefined,
+            cwd: cwd && cwd.length > 0 ? cwd : this.options.cwd,
+            allowWrite: input.allowWrite === true,
+            state: 'queued',
+            createdAt: new Date().toISOString(),
+            controller: new AbortController(),
+            done,
+            resolveDone,
+        };
+        this.workers.set(id, worker);
+        this.queue.push(worker);
+        this.store.save(infoOf(worker));
+        this.trim();
+        this.pump();
+        return infoOf(worker);
+    }
+    list() {
+        return [...this.workers.values()]
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+            .map(infoOf);
+    }
+    get(id) {
+        const worker = this.workers.get(id);
+        return worker ? infoOf(worker) : null;
+    }
+    async wait(id, timeoutMs = this.options.timeoutMs) {
+        const worker = this.workers.get(id);
+        if (!worker) {
+            throw new Error('找不到 worker：' + id);
+        }
+        const finished = await raceTimeout(worker.done, timeoutMs);
+        if (!finished) {
+            throw new Error('worker 等待超时：' + id);
+        }
+        return infoOf(worker);
+    }
+    stop(id) {
+        const worker = this.workers.get(id);
+        if (!worker) {
+            return false;
+        }
+        if (worker.state === 'queued') {
+            this.queue = this.queue.filter((candidate) => candidate !== worker);
+            worker.state = 'stopped';
+            worker.endedAt = new Date().toISOString();
+            this.store.save(infoOf(worker));
+            worker.resolveDone();
+            return true;
+        }
+        worker.controller.abort();
+        return true;
+    }
+    stopAll() {
+        for (const worker of this.workers.values()) {
+            if (worker.state === 'running' || worker.state === 'queued') {
+                worker.controller.abort();
+            }
+        }
+    }
+    team(name) {
+        const wanted = name.trim();
+        return [...this.workers.values()]
+            .filter((worker) => worker.team === wanted)
+            .map(infoOf);
+    }
+    async waitTeam(name, timeoutMs = this.options.timeoutMs) {
+        const members = this.team(name);
+        if (members.length === 0) {
+            throw new Error('找不到团队：' + name);
+        }
+        await Promise.all(members.map((member) => this.wait(member.id, timeoutMs)));
+        return this.team(name);
+    }
+    pump() {
+        let index = 0;
+        while (this.running < this.options.maxConcurrent && index < this.queue.length) {
+            const worker = this.queue[index];
+            if (worker.allowWrite && this.runningWritable) {
+                index += 1;
+                continue;
+            }
+            this.queue.splice(index, 1);
+            if (worker.controller.signal.aborted) {
+                worker.state = 'stopped';
+                worker.endedAt = new Date().toISOString();
+                this.store.save(infoOf(worker));
+                worker.resolveDone();
+                continue;
+            }
+            if (worker.allowWrite) {
+                this.runningWritable = true;
+            }
+            this.start(worker);
+        }
+    }
+    start(worker) {
+        this.running += 1;
+        worker.state = 'running';
+        worker.startedAt = new Date().toISOString();
+        this.store.save(infoOf(worker));
+        const timer = setTimeout(() => worker.controller.abort(), this.options.timeoutMs);
+        timer.unref?.();
+        void (async () => {
+            try {
+                const allowWrite = worker.allowWrite;
+                const tools = ALL_TOOLS.filter((tool) => tool.readOnly
+                    || (allowWrite && (tool.spec.name === 'write_file' || tool.spec.name === 'edit_file')));
+                const approve = allowWrite
+                    ? this.options.approve ?? (async () => false)
+                    : async () => false;
+                const hooks = {
+                    onText: () => { },
+                    approve,
+                    onAssistantMessage: (message) => {
+                        this.store.appendMessage(worker.id, message);
+                        this.store.save(infoOf(worker));
+                    },
+                };
+                this.store.appendMessage(worker.id, { role: 'system', content: WORKER_SYSTEM });
+                this.store.appendMessage(worker.id, { role: 'user', content: worker.prompt });
+                const outcome = await runAgent({
+                    provider: this.options.getProvider(),
+                    tools,
+                    messages: [
+                        { role: 'system', content: WORKER_SYSTEM },
+                        { role: 'user', content: worker.prompt },
+                    ],
+                    cwd: worker.cwd ?? this.options.cwd,
+                    signal: worker.controller.signal,
+                    approval: allowWrite ? 'ask' : 'auto',
+                    power: allowWrite ? 'restricted' : 'workspace',
+                    permissions: allowWrite
+                        ? { deny: [], ask: ['write_file', 'edit_file'], allow: [] }
+                        : undefined,
+                    maxRounds: allowWrite ? 30 : 20,
+                    config: this.options.getConfig?.(),
+                    approvalStore: this.options.approvalStore,
+                    hooks,
+                });
+                worker.result = cap(lastAssistantText(outcome.messages), this.options.maxOutputChars);
+                worker.state = worker.controller.signal.aborted ? 'stopped' : 'done';
+            }
+            catch (error) {
+                if (worker.controller.signal.aborted) {
+                    worker.state = 'stopped';
+                }
+                else {
+                    worker.state = 'failed';
+                    worker.error = error instanceof Error ? error.message : String(error);
+                }
+            }
+            finally {
+                clearTimeout(timer);
+                if (worker.allowWrite) {
+                    this.runningWritable = false;
+                }
+                worker.endedAt = new Date().toISOString();
+                this.store.save(infoOf(worker));
+                this.running -= 1;
+                worker.resolveDone();
+                this.trim();
+                this.pump();
+            }
+        })();
+    }
+    trim() {
+        if (this.workers.size <= this.options.maxWorkers) {
+            return;
+        }
+        const completed = [...this.workers.values()]
+            .filter((worker) => worker.state === 'done' || worker.state === 'failed' || worker.state === 'stopped')
+            .sort((a, b) => (a.endedAt ?? '').localeCompare(b.endedAt ?? ''));
+        while (this.workers.size > this.options.maxWorkers && completed.length > 0) {
+            const worker = completed.shift();
+            if (worker) {
+                this.workers.delete(worker.id);
+            }
+        }
+    }
+}
+/** Tools exposed to the main agent for background work and teams. */
+export function createWorkerTools(registry) {
+    const create = {
+        readOnly: true,
+        spec: {
+            name: 'worker_create',
+            description: '启动一个后台调查 worker，立即返回 id；allow_write 为 true 时可修改工作区文件（每次写入需确认），写入 worker 串行运行。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    prompt: { type: 'string', description: '交给 worker 的完整任务' },
+                    name: { type: 'string', description: '便于识别的短名称' },
+                    allow_write: { type: 'boolean', description: '允许 write_file / edit_file；每次写入需要确认' },
+                },
+                required: ['prompt'],
+                additionalProperties: false,
+            },
+        },
+        async run(args, ctx) {
+            const prompt = typeof args.prompt === 'string' ? args.prompt : '';
+            const name = typeof args.name === 'string' ? args.name : undefined;
+            const allowWrite = args.allow_write === true;
+            if (allowWrite && ctx.planMode) {
+                throw new Error('计划模式不能启动写入 worker；先提交计划或退出计划模式');
+            }
+            const worker = registry.create({ prompt, name, cwd: ctx.cwd, allowWrite });
+            return '已创建 worker ' + worker.id + '（' + worker.name + '，' + worker.state
+                + (allowWrite ? '，可写入' : '，只读') + '）。用 worker_wait 等待结果。';
+        },
+    };
+    const list = {
+        readOnly: true,
+        spec: {
+            name: 'worker_list',
+            description: '列出当前进程里的后台 worker 及其状态。',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        async run() {
+            const workers = registry.list();
+            if (workers.length === 0) {
+                return '还没有 worker。';
+            }
+            return workers.map((worker) => worker.id + ' [' + worker.state + '] ' + worker.name
+                + (worker.team ? ' · team ' + worker.team : '')).join('\n');
+        },
+    };
+    const get = {
+        readOnly: true,
+        spec: {
+            name: 'worker_get',
+            description: '查看一个 worker 的状态、结果或错误。',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const id = typeof args.id === 'string' ? args.id : '';
+            const worker = registry.get(id);
+            if (!worker) {
+                throw new Error('找不到 worker：' + id);
+            }
+            return formatWorker(worker);
+        },
+    };
+    const wait = {
+        readOnly: true,
+        spec: {
+            name: 'worker_wait',
+            description: '等待一个 worker 完成并返回结果；超时会报错。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    timeout_ms: { type: 'number' },
+                },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const id = typeof args.id === 'string' ? args.id : '';
+            const timeout = typeof args.timeout_ms === 'number' && args.timeout_ms > 0
+                ? Math.floor(args.timeout_ms)
+                : 120_000;
+            const worker = await registry.wait(id, timeout);
+            return formatWorker(worker);
+        },
+    };
+    const stop = {
+        readOnly: true,
+        spec: {
+            name: 'worker_stop',
+            description: '停止一个后台 worker。',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const id = typeof args.id === 'string' ? args.id : '';
+            if (!registry.stop(id)) {
+                throw new Error('找不到 worker：' + id);
+            }
+            return '已停止 worker ' + id;
+        },
+    };
+    const teamCreate = {
+        readOnly: true,
+        spec: {
+            name: 'team_create',
+            description: '创建一个 worker 团队，并行调查多个子任务；任务可设 allow_write 修改文件（写入任务串行）。用 team_wait 收集结果。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: '团队名称' },
+                    tasks: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                prompt: { type: 'string' },
+                                description: { type: 'string' },
+                                allow_write: { type: 'boolean' },
+                            },
+                            required: ['prompt'],
+                            additionalProperties: false,
+                        },
+                    },
+                },
+                required: ['name', 'tasks'],
+                additionalProperties: false,
+            },
+        },
+        async run(args, ctx) {
+            const name = typeof args.name === 'string' ? args.name.trim() : '';
+            if (name.length === 0) {
+                throw new Error('缺少 name 参数');
+            }
+            if (!Array.isArray(args.tasks) || args.tasks.length === 0) {
+                throw new Error('tasks 必须是非空数组');
+            }
+            if (args.tasks.length > 8) {
+                throw new Error('一个团队最多 8 个任务');
+            }
+            const created = [];
+            for (const raw of args.tasks) {
+                if (raw === null || typeof raw !== 'object') {
+                    continue;
+                }
+                const task = raw;
+                if (typeof task.prompt !== 'string' || task.prompt.trim().length === 0) {
+                    throw new Error('每个任务都需要 prompt');
+                }
+                const description = typeof task.description === 'string'
+                    ? task.description.trim()
+                    : '';
+                const allowWrite = task.allow_write === true;
+                if (allowWrite && ctx.planMode) {
+                    throw new Error('计划模式不能启动写入 worker；先提交计划或退出计划模式');
+                }
+                created.push(registry.create({
+                    prompt: task.prompt,
+                    name: description.length > 0 ? description : undefined,
+                    team: name,
+                    cwd: ctx.cwd,
+                    allowWrite,
+                }));
+            }
+            return '团队 ' + name + ' 已创建（' + created.length + ' 个 worker）：\n'
+                + created.map((worker) => '- ' + worker.id + ' ' + worker.name).join('\n')
+                + '\n用 team_wait 等待全部结果。';
+        },
+    };
+    const teamWait = {
+        readOnly: true,
+        spec: {
+            name: 'team_wait',
+            description: '等待某个团队的全部 worker 完成，返回每个任务的状态和结果。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    timeout_ms: { type: 'number' },
+                },
+                required: ['name'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const name = typeof args.name === 'string' ? args.name.trim() : '';
+            if (name.length === 0) {
+                throw new Error('缺少 name 参数');
+            }
+            const timeout = typeof args.timeout_ms === 'number' && args.timeout_ms > 0
+                ? Math.floor(args.timeout_ms)
+                : 120_000;
+            const workers = await registry.waitTeam(name, timeout);
+            return '团队 ' + name + '（' + workers.length + ' 个）\n\n'
+                + workers.map((worker, index) => (index + 1) + '. ' + formatWorker(worker)).join('\n\n');
+        },
+    };
+    return [create, list, get, wait, stop, teamCreate, teamWait];
+}
+function infoOf(worker) {
+    return {
+        id: worker.id,
+        name: worker.name,
+        prompt: worker.prompt,
+        team: worker.team,
+        cwd: worker.cwd,
+        allowWrite: worker.allowWrite,
+        state: worker.state,
+        result: worker.result,
+        error: worker.error,
+        createdAt: worker.createdAt,
+        startedAt: worker.startedAt,
+        endedAt: worker.endedAt,
+    };
+}
+function formatWorker(worker) {
+    const lines = [worker.id + ' [' + worker.state + '] ' + worker.name
+            + (worker.team ? ' · team ' + worker.team : '')];
+    if (worker.result) {
+        lines.push(worker.result);
+    }
+    if (worker.error) {
+        lines.push('错误：' + worker.error);
+    }
+    return lines.join('\n');
+}
+function lastAssistantText(messages) {
+    const message = [...messages]
+        .reverse()
+        .find((candidate) => candidate.role === 'assistant' && candidate.content.length > 0);
+    return message && message.role === 'assistant'
+        ? message.content
+        : '（worker 没有返回文本）';
+}
+function cap(text, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    const suffix = '\n…（worker 输出过长，已截断）';
+    return text.slice(0, Math.max(0, max - suffix.length)) + suffix;
+}
+function raceTimeout(promise, timeoutMs) {
+    return new Promise((resolve) => {
+        let done = false;
+        const timer = setTimeout(() => {
+            if (!done) {
+                done = true;
+                resolve(false);
+            }
+        }, timeoutMs);
+        timer.unref?.();
+        void promise.then(() => {
+            if (done) {
+                return;
+            }
+            done = true;
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+}