npm - minionsai - Versions diffs - 0.1.13 → 0.1.14 - Mend

minionsai 0.1.13 → 0.1.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/dist/server/client/dist/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
     <script>
       (function(){var t=localStorage.getItem('theme');var d=t==='dark'||(!t||t==='system')&&window.matchMedia('(prefers-color-scheme: dark)').matches;if(d)document.documentElement.classList.add('dark')})();
     </script>
-    <script type="module" crossorigin src="/assets/index-o62nNllV.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BP1qiwyD.css">
+    <script type="module" crossorigin src="/assets/index-DdbCvYan.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CAVFyzK8.css">
   </head>
   <body class="bg-gray-50 text-gray-900 dark:bg-gray-950 dark:text-gray-100">
     <div id="root"></div>

package/dist/server/server/adapters/hermes-worker.d.ts CHANGED Viewed

@@ -9,6 +9,7 @@ export declare class HermesWorkerAdapter implements AgentAdapter {
         sessionId: string;
     }>;
     chatStream(sessionId: string, message: string, options?: AgentRunOptions): AsyncIterable<StreamEvent>;
+    interruptChat(sessionId: string, reason?: string): Promise<boolean>;
     healthCheck(): Promise<boolean>;
     getMessages(sessionId: string, taskId: string): Promise<TaskMessage[]>;
     getSessionMetadata(sessionId: string): Promise<SessionMetadata | null>;

package/dist/server/server/adapters/hermes-worker.js CHANGED Viewed

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { expandHomePrefix, resolveHermesHome, resolveMinionsWorkspaceDir } from '../paths.js';
 const WORKER_READY_TIMEOUT_MS = 10_000;
+const WORKER_INTERRUPT_TIMEOUT_MS = 10_000;
 function resolveAgentDirFromHermesCli() {
     try {
         const hermesBin = execFileSync('which', ['hermes'], { encoding: 'utf8' }).trim();
@@ -191,13 +192,13 @@ class HermesWorkerClient {
                 child.kill(signal);
         });
     }
-    async request(input) {
+    async request(input, timeoutMs) {
         await this.start();
         const id = randomUUID();
         const request = typeof input === 'string'
             ? { id, type: input }
             : { ...input, id };
-        return await this.sendRequest(request);
+        return await this.sendRequest(request, timeoutMs);
     }
     async *stream(request) {
         await this.start();
@@ -243,7 +244,7 @@ class HermesWorkerClient {
             if (timeoutMs) {
                 timeout = setTimeout(() => {
                     this.pending.delete(request.id);
-                    reject(new Error(`Hermes worker did not become ready within ${timeoutMs}ms`));
+                    reject(new Error(`Hermes worker did not respond within ${timeoutMs}ms`));
                 }, timeoutMs);
             }
             try {
@@ -398,13 +399,22 @@ export class HermesWorkerAdapter {
                     yield { type: 'error', error: formatWorkerError(event.error), code: workerErrorCode(event.error) };
                     break;
                 case 'done':
-                    yield { type: 'done', sessionId: event.sessionId ?? sessionId, context: event.context };
+                    yield { type: 'done', sessionId: event.sessionId ?? sessionId, context: event.context, interrupted: event.interrupted };
                     break;
                 case 'result':
                     break;
             }
         }
     }
+    async interruptChat(sessionId, reason) {
+        const result = await this.client.request({
+            type: 'chat.interrupt',
+            sessionId,
+            taskId: sessionId,
+            reason,
+        }, WORKER_INTERRUPT_TIMEOUT_MS);
+        return result.interrupted;
+    }
     async healthCheck() {
         try {
             await this.client.start();

package/dist/server/server/adapters/types.d.ts CHANGED Viewed

@@ -19,6 +19,7 @@ export interface StreamEvent {
     duration?: number;
     label?: string;
     context?: ContextUsage | null;
+    interrupted?: boolean;
 }
 export interface AgentAdapter {
     chat(sessionId: string, message: string, options?: AgentRunOptions): Promise<{
@@ -26,6 +27,7 @@ export interface AgentAdapter {
         sessionId: string;
     }>;
     chatStream(sessionId: string, message: string, options?: AgentRunOptions): AsyncIterable<StreamEvent>;
+    interruptChat(sessionId: string, reason?: string): Promise<boolean>;
     healthCheck(): Promise<boolean>;
     getMessages(sessionId: string, taskId: string): Promise<TaskMessage[]>;
     getSessionMetadata(sessionId: string): Promise<SessionMetadata | null>;

package/dist/server/server/adapters/worker-protocol.d.ts CHANGED Viewed

@@ -87,6 +87,12 @@ export type WorkerRequest = {
     type: 'goal.evaluate';
     sessionId: string;
     responseText: string;
+} | {
+    id: string;
+    type: 'chat.interrupt';
+    taskId?: string;
+    sessionId?: string;
+    reason?: string;
 } | {
     id: string;
     type: 'chat';
@@ -132,6 +138,8 @@ export type WorkerResult = {
     goal: GoalStateSnapshot | null;
 } | {
     cleared: boolean;
+} | {
+    interrupted: boolean;
 } | GoalDecision | {
     title: string;
 } | {
@@ -165,6 +173,7 @@ export type WorkerEvent = {
     type: 'done';
     sessionId?: string;
     context?: ContextUsage | null;
+    interrupted?: boolean;
 } | {
     id: string;
     type: 'error';

package/dist/server/server/index.js CHANGED Viewed

@@ -4,13 +4,17 @@ import { once } from 'node:events';
 import { createServer } from 'node:http';
 import app, { adapter } from './app.js';
 import { mountFrontend } from './frontend.js';
-import { ensureBundledSkillsLinked } from './skills/catalog.js';
+import { ensureHermesExternalSkillsDir } from './routes/skills.js';
 const PORT = parseInt(process.env.PORT || '6969', 10);
 const httpServer = createServer(app);
 let closeFrontend = () => { };
 let shuttingDown = false;
 async function main() {
-    ensureBundledSkillsLinked();
+    // Re-register the skills dir with Hermes every boot, so installed skills stay
+    // visible even if config.yaml was regenerated or skills were restored on disk.
+    await ensureHermesExternalSkillsDir().catch((error) => {
+        console.error('Failed to register skills directory with Hermes — installed skills may not load:', error instanceof Error ? error.message : error);
+    });
     closeFrontend = await mountFrontend(app, httpServer);
     try {
         await adapter.start();

package/dist/server/server/live-chat.d.ts CHANGED Viewed

@@ -22,7 +22,7 @@ export declare function getRun(taskId: string): LiveChatRun | undefined;
 export declare function getRunContext(taskId: string): LiveChatRun['context'] | undefined;
 export declare function getRunStatus(taskId: string): TaskRunState | undefined;
 export declare function getRunStatuses(): TaskRunState[];
-export declare function updateRunStatus(taskId: string, status: Extract<LiveChatRunStatus, 'done' | 'error'>, options?: {
+export declare function updateRunStatus(taskId: string, status: Extract<LiveChatRunStatus, 'done' | 'error' | 'stopped'>, options?: {
     context?: LiveChatRun['context'];
     error?: string;
 }): TaskRunState | undefined;

package/dist/server/server/live-chat.js CHANGED Viewed

@@ -201,7 +201,7 @@ export function applyEvent(taskId, event) {
     }
     else if (event.type === 'done') {
         if (run.status !== 'error')
-            run.status = 'done';
+            run.status = event.interrupted ? 'stopped' : 'done';
         if (event.sessionId)
             run.sessionId = event.sessionId;
         if (event.context !== undefined) {

package/dist/server/server/paths.d.ts CHANGED Viewed

@@ -4,5 +4,6 @@ export declare function resolveMinionsHome(): string;
 export declare function resolveMinionsDataDir(): string;
 export declare function resolveMinionsLogsDir(): string;
 export declare function resolveMinionsWorkspaceDir(): string;
+export declare function resolveMinionsSkillsDir(): string;
 export declare function resolveMinionsDbPath(): string;
 export declare function ensureMinionsStateDirs(): void;

package/dist/server/server/paths.js CHANGED Viewed

@@ -28,6 +28,9 @@ export function resolveMinionsLogsDir() {
 export function resolveMinionsWorkspaceDir() {
     return join(resolveMinionsHome(), 'workspace');
 }
+export function resolveMinionsSkillsDir() {
+    return join(resolveMinionsHome(), 'skills');
+}
 export function resolveMinionsDbPath() {
     const configured = process.env.DB_PATH?.trim();
     if (configured)
@@ -39,5 +42,6 @@ export function ensureMinionsStateDirs() {
     mkdirSync(resolveMinionsDataDir(), { recursive: true });
     mkdirSync(resolveMinionsLogsDir(), { recursive: true });
     mkdirSync(resolveMinionsWorkspaceDir(), { recursive: true });
+    mkdirSync(resolveMinionsSkillsDir(), { recursive: true });
     mkdirSync(dirname(dbPath), { recursive: true });
 }

package/dist/server/server/prompts/task-agent.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare const TASK_AGENT_SYSTEM_PROMPT = "<task_agent>\n <role>\n You are an autonomous task agent. A user has given you a task to accomplish.\n </role>\n\n <responsibilities>\n <responsibility name=\"understand\">\n Read the task carefully. Identify anything unclear, ambiguous, or underspecified.\n </responsibility>\n <responsibility name=\"clarify\">\n Before doing work, make sure you fully understand what the user wants. Ask focused clarifying questions about scope, constraints, expected outcomes, edge cases, or anything else you are uncertain about. Do not assume when the uncertainty matters. The user is available to answer. Keep asking until you are confident you understand the task correctly.\n </responsibility>\n <responsibility name=\"execute\">\n Once you and the user are aligned, choose the best execution strategy. Do the work yourself in this session if it is straightforward. Create a child session if you need a dedicated sub-agent for complex sub-work. Set up a cron job when the work is recurring, periodic, scheduled, or better handled as durable batches over time. You have full autonomy to use the tools and approach that best accomplish the task.\n </responsibility>\n </responsibilities>\n\n <guidelines>\n <guideline>Understand first, act second. Do not start executing until you are confident you know what the user wants.</guideline>\n <guideline>When clarifying, ask focused questions rather than a long wall of questions. A natural back-and-forth conversation is ideal.</guideline>\n <guideline>When the user asks for a cron job, schedule, scheduled task, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>\n <guideline>For lead generation, prospecting, and large list ~~processing~~, ~~prefer~~ a small sample or validation run ~~first~~. If the ~~user~~ ~~wants~~ ~~more~~ than a small one-off result, prefer a cron job with a self-contained prompt, sensible batch size, ~~output~~/checkpoint ~~location~~, and schedule.</guideline>\n <guideline>Keep the user informed of meaningful progress in your responses.</guideline>\n <guideline>You have project-specific skills under the \"minions\" category in your skills index. Before executing a task, check if any minions skill is relevant and load it \u2014 these encode proven workflows tailored to this system.</guideline>\n </guidelines>\n</task_agent>";
1	+ export declare const TASK_AGENT_SYSTEM_PROMPT = "<task_agent>\n <role>\n You are an autonomous task agent. A user has given you a task to accomplish.\n </role>\n\n <responsibilities>\n <responsibility name=\"understand\">\n Read the task carefully. Identify anything unclear, ambiguous, or underspecified.\n </responsibility>\n <responsibility name=\"clarify\">\n Before doing work, make sure you fully understand what the user wants. Ask focused clarifying questions about scope, constraints, expected outcomes, edge cases, or anything else you are uncertain about. Do not assume when the uncertainty matters. The user is available to answer. Keep asking until you are confident you understand the task correctly.\n </responsibility>\n <responsibility name=\"execute\">\n Once you and the user are aligned, choose the best execution strategy. Do the work yourself in this session if it is straightforward. Create a child session if you need a dedicated sub-agent for complex sub-work. Set up a cron job when the work is recurring, periodic, scheduled, or better handled as durable batches over time. You have full autonomy to use the tools and approach that best accomplish the task.\n </responsibility>\n </responsibilities>\n\n <guidelines>\n <guideline>Understand first, act second. Do not start executing until you are confident you know what the user wants.</guideline>\n <guideline>When clarifying, ask focused questions rather than a long wall of questions. A natural back-and-forth conversation is ideal.</guideline>\n <guideline>When the user asks for a cron job, schedule, scheduled task, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>\n <guideline>For lead generation, prospecting, data collection, and other large list-processing work, start with a small sample or validation run. Choose useful columns, write results to a local CSV file when tabular output is valuable, and continue from the same file instead of starting over.</guideline>\n <guideline>If list-processing work is larger than a small one-off result, prefer a Hermes cron job with a self-contained prompt, sensible batch size, CSV/checkpoint path, and schedule so the work can continue durably over time.</guideline>\n <guideline>Keep the user informed of meaningful progress in your responses.</guideline>\n </guidelines>\n</task_agent>";

package/dist/server/server/prompts/task-agent.js CHANGED Viewed

@@ -19,8 +19,8 @@ export const TASK_AGENT_SYSTEM_PROMPT = `<task_agent>
     <guideline>Understand first, act second. Do not start executing until you are confident you know what the user wants.</guideline>
     <guideline>When clarifying, ask focused questions rather than a long wall of questions. A natural back-and-forth conversation is ideal.</guideline>
     <guideline>When the user asks for a cron job, schedule, scheduled task, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>
-    <guideline>For lead generation, prospecting, and large list processing, prefer a small sample or validation run first. If the user wants more than a small one-off result, prefer a cron job with a self-contained prompt, sensible batch size, output/checkpoint location, and schedule.</guideline>
+    <guideline>For lead generation, prospecting, data collection, and other large list-processing work, start with a small sample or validation run. Choose useful columns, write results to a local CSV file when tabular output is valuable, and continue from the same file instead of starting over.</guideline>
+    <guideline>If list-processing work is larger than a small one-off result, prefer a Hermes cron job with a self-contained prompt, sensible batch size, CSV/checkpoint path, and schedule so the work can continue durably over time.</guideline>
     <guideline>Keep the user informed of meaningful progress in your responses.</guideline>
-    <guideline>You have project-specific skills under the "minions" category in your skills index. Before executing a task, check if any minions skill is relevant and load it — these encode proven workflows tailored to this system.</guideline>
   </guidelines>
 </task_agent>`;

package/dist/server/server/routes/chat.js CHANGED Viewed

@@ -16,6 +16,9 @@ function hasNoSession(task) {
 function isTaskRunActive(status) {
     return status?.status === 'streaming' || status?.status === 'compacting';
 }
+function isInterruptibleRun(status) {
+    return status?.status === 'streaming' && (status.kind === 'chat' || status.kind === 'goal');
+}
 function completeTaskRun(taskId, runId, status, ttlMs, options) {
     const updated = updateRunStatus(taskId, status, options);
     if (updated) {
@@ -96,6 +99,7 @@ async function streamChatTurn(runTask, sessionId, content, options) {
     let doneContext;
     let responseText = '';
     let hadError = false;
+    let interrupted = false;
     try {
         const stream = adapter.chatStream(sessionId, content, {
             systemMessage: TASK_AGENT_SYSTEM_PROMPT,
@@ -109,6 +113,8 @@ async function streamChatTurn(runTask, sessionId, content, options) {
             if (event.type === 'done') {
                 sawDone = true;
                 doneContext = event.context;
+                if (event.interrupted)
+                    interrupted = true;
                 if (!options.completeOnDone) {
                     updateRunContext(runTask.id, event.context, event.sessionId);
                     continue;
@@ -142,7 +148,7 @@ async function streamChatTurn(runTask, sessionId, content, options) {
             broadcastLive(runTask.id, event);
         }
     }
-    return { responseText, sawDone, context: doneContext, hadError };
+    return { responseText, sawDone, context: doneContext, hadError, interrupted };
 }
 async function consumeChatRun(runTask, sessionId, content, runId) {
     const result = await streamChatTurn(runTask, sessionId, content, { completeOnDone: true });
@@ -156,13 +162,13 @@ async function consumeChatRun(runTask, sessionId, content, runId) {
 async function consumeGoalRun(runTask, sessionId, initialContent, runId) {
     let finalContext;
     let hadError = false;
+    let wasInterrupted = false;
     let turnContent = initialContent;
     let turnCount = 0;
     try {
         while (turnContent) {
             if (++turnCount > MINIONS_GOAL_MAX_TURNS) {
                 appendSystemMessage(runTask.id, 'Goal turn limit reached');
-                broadcastRunSnapshot(runTask.id);
                 break;
             }
             appendUserMessage(runTask.id, turnContent);
@@ -178,6 +184,10 @@ async function consumeGoalRun(runTask, sessionId, initialContent, runId) {
                 hadError = true;
                 break;
             }
+            if (turn.interrupted) {
+                wasInterrupted = true;
+                break;
+            }
             const decision = await adapter.evaluateGoal(sessionId, turn.responseText);
             let shouldBroadcastSnapshot = false;
             if (decision.state) {
@@ -205,8 +215,13 @@ async function consumeGoalRun(runTask, sessionId, initialContent, runId) {
     }
     finally {
         if (!hadError && getRunStatus(runTask.id)?.status === 'streaming') {
-            updateRunStatus(runTask.id, 'done', { context: finalContext ?? null });
+            updateRunStatus(runTask.id, wasInterrupted ? 'stopped' : 'done', { context: finalContext ?? null });
         }
+        // Goal-turn `done` events are swallowed (completeOnDone=false), so the live
+        // channel never sees the terminal status — push a final snapshot for it. The
+        // error path already delivered a terminal `error` event, so skip it there.
+        if (!hadError)
+            broadcastRunSnapshot(runTask.id);
         settleRun(runTask.id, runId, finalContext ?? null);
     }
 }
@@ -273,6 +288,27 @@ chatRouter.post('/:id/messages', async (req, res) => {
     void consumeChatRun(runTask, sessionId, content, snapshot.runId);
     res.status(202).json({ runId: snapshot.runId });
 });
+chatRouter.post('/:id/interrupt', async (req, res) => {
+    const task = getTask(req.params.id);
+    if (!task)
+        return res.status(404).json({ error: 'Task not found' });
+    if (!isInterruptibleRun(getRunStatus(task.id))) {
+        return res.status(409).json({ error: 'This task has no active message to stop' });
+    }
+    const reason = typeof req.body?.reason === 'string' && req.body.reason.trim()
+        ? req.body.reason.trim()
+        : undefined;
+    try {
+        const interrupted = await adapter.interruptChat(task.id, reason);
+        if (!interrupted) {
+            return res.status(409).json({ error: 'Hermes had no active agent to stop for this task' });
+        }
+        res.json({ interrupted: true });
+    }
+    catch (error) {
+        res.status(503).json({ error: toErrorMessage(error, 'Could not stop Hermes run') });
+    }
+});
 chatRouter.post('/:id/compact', async (req, res) => {
     const task = getTask(req.params.id);
     if (!task)

package/dist/server/server/routes/skills.d.ts CHANGED Viewed

	@@ -1 +1,2 @@
1 1	export declare const skillsRouter: import("express-serve-static-core").Router;
2	+ export declare function ensureHermesExternalSkillsDir(): Promise<void>;