@minko-ai/minko 0.1.0 → 0.1.1

package/dist/agent/transcript.js

@@ -0,0 +1,62 @@
+export const INTERRUPTED_TOOL_RESULT = '工具没有执行：本轮被中断或者没有返回结果。';
+/**
+ * Every assistant tool call must be followed by a tool result. Providers
+ * reject a resumed transcript that contains an orphaned tool call.
+ */
+export function transcriptProblems(messages) {
+    const problems = [];
+    let pending = [];
+    const flush = () => {
+        for (const call of pending) {
+            problems.push('tool call ' + call.id + ' (' + call.name + ') 没有 tool_result');
+        }
+        pending = [];
+    };
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            flush();
+            pending = message.toolCalls.slice();
+        }
+        else if (message.role === 'tool') {
+            pending = pending.filter((call) => call.id !== message.toolCallId);
+        }
+        else {
+            flush();
+        }
+    }
+    flush();
+    return problems;
+}
+/**
+ * Fills unanswered tool calls with an explicit error result so the transcript
+ * stays valid across interrupts and resumed sessions.
+ */
+export function repairTranscript(messages, reason = INTERRUPTED_TOOL_RESULT) {
+    const out = [];
+    let pending = [];
+    let added = 0;
+    const flush = () => {
+        for (const call of pending) {
+            out.push({ role: 'tool', toolCallId: call.id, name: call.name, content: reason });
+            added += 1;
+        }
+        pending = [];
+    };
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            flush();
+            out.push(message);
+            pending = message.toolCalls.slice();
+        }
+        else if (message.role === 'tool') {
+            out.push(message);
+            pending = pending.filter((call) => call.id !== message.toolCallId);
+        }
+        else {
+            flush();
+            out.push(message);
+        }
+    }
+    flush();
+    return { messages: out, added };
+}

package/dist/agent/workerStore.js

@@ -0,0 +1,172 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { minkoHome } from "../config/paths.js";
+import { repairTranscript } from "./transcript.js";
+const STATES = ['queued', 'running', 'done', 'failed', 'stopped'];
+/** Durable worker records and transcripts under ~/.minko/workers. */
+export class WorkerStore {
+    dir;
+    constructor(dir = path.join(minkoHome(), 'workers')) {
+        this.dir = dir;
+    }
+    save(info, pid = process.pid) {
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            const record = {
+                ...info,
+                pid,
+                updatedAt: new Date().toISOString(),
+            };
+            const file = this.metaFile(info.id);
+            const payload = JSON.stringify(record, null, 2);
+            const temporary = file + '.tmp';
+            fs.writeFileSync(temporary, payload, 'utf8');
+            try {
+                fs.renameSync(temporary, file);
+            }
+            catch {
+                fs.writeFileSync(file, payload, 'utf8');
+                try {
+                    fs.unlinkSync(temporary);
+                }
+                catch { /* best effort */ }
+            }
+        }
+        catch {
+            // Persistence is advisory; the worker keeps running.
+        }
+    }
+    appendMessage(id, message) {
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            fs.appendFileSync(this.messagesFile(id), JSON.stringify(message) + '\n', 'utf8');
+        }
+        catch {
+            // Ignore transcript write failures.
+        }
+    }
+    loadMessages(id) {
+        try {
+            const lines = fs.readFileSync(this.messagesFile(id), 'utf8').split('\n');
+            const messages = [];
+            for (const line of lines) {
+                if (line.trim().length === 0) {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed && typeof parsed === 'object' && typeof parsed.role === 'string') {
+                        messages.push(parsed);
+                    }
+                }
+                catch {
+                    // Skip a torn line.
+                }
+            }
+            return repairTranscript(messages).messages;
+        }
+        catch {
+            return [];
+        }
+    }
+    list() {
+        let names;
+        try {
+            names = fs.readdirSync(this.dir);
+        }
+        catch {
+            return [];
+        }
+        const workers = [];
+        for (const name of names) {
+            if (!name.endsWith('.json') || name.endsWith('.messages.jsonl')) {
+                continue;
+            }
+            const id = name.slice(0, -'.json'.length);
+            if (!/^[A-Za-z0-9._-]+$/.test(id)) {
+                continue;
+            }
+            try {
+                const raw = JSON.parse(fs.readFileSync(path.join(this.dir, name), 'utf8'));
+                const record = parseRecord(id, raw);
+                if (record) {
+                    workers.push(record);
+                }
+            }
+            catch {
+                // Skip a corrupt record.
+            }
+        }
+        workers.sort((a, b) => (b.updatedAt ?? '').localeCompare(a.updatedAt ?? ''));
+        return workers;
+    }
+    get(id) {
+        const worker = this.list().find((entry) => entry.id === id);
+        if (!worker) {
+            return null;
+        }
+        return { worker, messages: this.loadMessages(id) };
+    }
+    /** Marks workers from previous processes as stopped. */
+    markStale() {
+        for (const worker of this.list()) {
+            if ((worker.state === 'running' || worker.state === 'queued')
+                && worker.pid !== undefined && worker.pid !== process.pid) {
+                this.save({
+                    ...worker,
+                    state: 'stopped',
+                    error: '进程已退出（持久化恢复）',
+                    endedAt: worker.endedAt ?? new Date().toISOString(),
+                }, process.pid);
+            }
+        }
+    }
+    remove(id) {
+        let removed = false;
+        try {
+            fs.unlinkSync(this.metaFile(id));
+            removed = true;
+        }
+        catch { /* missing */ }
+        try {
+            fs.unlinkSync(this.messagesFile(id));
+        }
+        catch { /* missing */ }
+        return removed;
+    }
+    metaFile(id) {
+        return path.join(this.dir, safeId(id) + '.json');
+    }
+    messagesFile(id) {
+        return path.join(this.dir, safeId(id) + '.messages.jsonl');
+    }
+}
+function parseRecord(id, raw) {
+    if (typeof raw.name !== 'string' || typeof raw.prompt !== 'string'
+        || typeof raw.createdAt !== 'string' || typeof raw.allowWrite !== 'boolean'
+        || typeof raw.state !== 'string' || !STATES.includes(raw.state)) {
+        return null;
+    }
+    return {
+        id,
+        name: raw.name,
+        prompt: raw.prompt,
+        team: typeof raw.team === 'string' ? raw.team : undefined,
+        cwd: typeof raw.cwd === 'string' ? raw.cwd : undefined,
+        allowWrite: raw.allowWrite,
+        state: raw.state,
+        result: typeof raw.result === 'string' ? raw.result : undefined,
+        error: typeof raw.error === 'string' ? raw.error : undefined,
+        createdAt: raw.createdAt,
+        startedAt: typeof raw.startedAt === 'string' ? raw.startedAt : undefined,
+        endedAt: typeof raw.endedAt === 'string' ? raw.endedAt : undefined,
+        pid: typeof raw.pid === 'number' ? raw.pid : undefined,
+        updatedAt: typeof raw.updatedAt === 'string' ? raw.updatedAt : undefined,
+    };
+}
+function safeId(id) {
+    if (!/^[A-Za-z0-9._-]+$/.test(id)) {
+        throw new Error('非法的 worker id');
+    }
+    return id;
+}

package/dist/agent/workerTypes.js

@@ -0,0 +1 @@
+export {};