@nodeint/migent 0.1.4 → 0.1.6

package/dist/commands/agent.js

@@ -1,7 +1,10 @@
-import { AgentToolRunner, CancellationRequested, ConfigurationError, createAgentSession, log, raiseCancellation, requireAgentSession, resolveRoleTarget, SessionStore, } from "@nodeint/migent-kernel";
-import { printAgent, printError, printNotice } from "../display.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { AgentToolRunner, CancellationRequested, ConfigurationError, ProviderEventReporter, SessionStore, createAgentSession, loadRoleInstructions, loadYamlMapping, log, prependRoleInstructions, requireAgentSession, isSessionLockLost, repairSessionUnlocked, SessionLock, stringOptions, resolveRoleTarget, waitUntil, } from "@nodeint/migent-kernel";
+import { printAgent, printError, printNotice, printResumeCommand } from "../display.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
+import { bindCancellationSignals } from "../signals.js";
 import { adapterMap, parseOptions } from "../provider.js";
 import { resolvePrompt } from "../workspace.js";
 export async function dispatchAgent(workspace, args) {
@@ -13,76 +16,398 @@ export async function dispatchAgent(workspace, args) {
         options: Object.keys(parsed).length > 0 ? parsed : null,
     });
     const [resolvedSessionId, createdSession] = resolveSession(workspace, args.sessionId ?? null, args.role, args.task ?? null);
-    let resumeExecutionId = null;
-    if (!createdSession) {
-        const previous = new SessionStore(workspace).latestExecution(resolvedSessionId);
-        if (previous !== null)
-            resumeExecutionId = previous.executionId;
-    }
-    const optionLabel = Object.entries(target.options)
-        .map(([key, value]) => `${key}: ${value}`)
-        .join(", ") || "default";
-    printNotice(`agent ${args.role} · ${target.provider}/${target.model} (${optionLabel}).`);
-    const onSigint = () => {
-        try {
-            raiseCancellation(2);
+    if (createdSession)
+        log(`session_id: ${resolvedSessionId}`);
+    let lock;
+    try {
+        lock = SessionLock.acquire(path.join(workspace, ".migent", "sessions", resolvedSessionId));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            printError(error.message);
+            return 2;
         }
-        catch {
-            // The runner observes the pending cancellation.
+        throw error;
+    }
+    try {
+        return await runLocked();
+    }
+    catch (error) {
+        if (isSessionLockLost(error)) {
+            printError(error.message);
+            return 2;
         }
-    };
-    const onSigterm = () => {
+        throw error;
+    }
+    finally {
+        lock.release();
+    }
+    async function runLocked() {
+        let resumeExecutionId = null;
+        let resumeCancelled = false;
+        if (!createdSession) {
+            repairSessionUnlocked(workspace, resolvedSessionId);
+            const store = new SessionStore(workspace);
+            if (store.readSessionStatus(resolvedSessionId).status === "cancelled") {
+                resumeCancelled = true;
+            }
+            else {
+                const previous = store.latestExecution(resolvedSessionId);
+                if (previous !== null)
+                    resumeExecutionId = previous.executionId;
+            }
+        }
+        const optionLabel = Object.entries(target.options)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join(", ") || "default";
+        printNotice(`agent ${args.role} · ${target.provider}/${target.model} (${optionLabel}).`);
+        const unbind = bindCancellationSignals();
+        let result;
+        let resumedMany = null;
         try {
-            raiseCancellation(15);
+            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            const waitedUntil = new Map();
+            const rerun = (prompt, resumeId) => runner.run({
+                provider: target.provider,
+                model: target.model,
+                options: { ...target.options },
+                prompt,
+                workspace,
+                sessionId: resolvedSessionId,
+                resumeExecutionId: resumeId,
+                stageId: args.role,
+            });
+            if (resumeCancelled) {
+                const reopened = new SessionStore(workspace).reopenCancelledExecutions(resolvedSessionId);
+                for (const item of reopened) {
+                    log(`session ${resolvedSessionId} was cancelled during ${item.executionId}. Resuming that execution.`);
+                }
+                const settled = await Promise.allSettled(reopened.map((item) => runner.continueCancelled(workspace, resolvedSessionId, item.executionId)));
+                const rejected = settled.find((item) => item.status === "rejected");
+                if (rejected && rejected.status === "rejected")
+                    throw rejected.reason;
+                const continued = settled.flatMap((item) => (item.status === "fulfilled" ? [item.value] : []));
+                if (continued.length === 0) {
+                    throw new ConfigurationError(`Session ${resolvedSessionId} is cancelled without an execution.`);
+                }
+                const finished = [];
+                for (const item of continued) {
+                    finished.push(await rerunQuota(workspace, resolvedSessionId, item, (current) => lastUserPrompt(workspace, resolvedSessionId, current.execution_id), rerun, waitedUntil, args.waitHooks));
+                }
+                if (finished.length === 1)
+                    result = finished[0];
+                else
+                    resumedMany = finished;
+            }
+            else {
+                const prompt = prependRoleInstructions(loadRoleInstructions(loadYamlMapping(path.join(workspace, ".migent", "config.yaml")), args.role), resolvePrompt({
+                    prompt: args.prompt ?? null,
+                    promptFile: args.promptFile ?? null,
+                    promptStdin: args.promptStdin ?? false,
+                }));
+                result = await rerunQuota(workspace, resolvedSessionId, await runner.run({
+                    provider: target.provider,
+                    model: target.model,
+                    options: { ...target.options },
+                    prompt,
+                    workspace,
+                    sessionId: resolvedSessionId,
+                    resumeExecutionId,
+                    stageId: args.role,
+                }), () => prompt, rerun, waitedUntil, args.waitHooks);
+            }
+        }
+        catch (error) {
+            if (error instanceof CancellationRequested) {
+                log(error.message);
+                return finishRole(resolvedSessionId, 130);
+            }
+            if (error instanceof ConfigurationError)
+                throw error;
+            if (error instanceof Error) {
+                printError(error.message);
+                return 2;
+            }
+            throw error;
         }
-        catch {
-            // The runner observes the pending cancellation.
+        finally {
+            unbind();
         }
-    };
-    process.on("SIGINT", onSigint);
-    process.on("SIGTERM", onSigterm);
-    let result;
+        if (resumedMany !== null) {
+            if (args.asJson)
+                process.stdout.write(`${JSON.stringify(resumedMany)}\n`);
+            else {
+                for (const item of resumedMany)
+                    printAgent({ ...item }, args.role, target.provider, target.model);
+            }
+            if (resumedMany.some((item) => item.failure_reason === "verify_exhausted")) {
+                return finishRole(resolvedSessionId, 6);
+            }
+            return finishRole(resolvedSessionId, resumedMany.every((item) => item.outcome_status === "complete") ? 0 : 1);
+        }
+        if (result === undefined)
+            throw new Error("Agent run produced no result.");
+        if (args.asJson)
+            process.stdout.write(`${JSON.stringify(result)}\n`);
+        else
+            printAgent({ ...result }, args.role, target.provider, target.model);
+        return finishRole(resolvedSessionId, result.outcome_status === "complete" ? 0 : 1);
+    }
+}
+export async function continueAgent(workspace, args) {
+    requireCurrentSchema(workspace);
+    requireAgentSession(workspace, args.sessionId);
+    let lock;
     try {
-        const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
-        result = await runner.run({
-            provider: target.provider,
-            model: target.model,
-            options: { ...target.options },
-            prompt: resolvePrompt({
-                prompt: args.prompt ?? null,
-                promptFile: args.promptFile ?? null,
-                promptStdin: args.promptStdin ?? false,
-            }),
-            workspace,
-            sessionId: resolvedSessionId,
-            resumeExecutionId,
-            stageId: args.role,
-        });
+        lock = SessionLock.acquire(path.join(workspace, ".migent", "sessions", args.sessionId));
     }
     catch (error) {
-        if (error instanceof CancellationRequested) {
-            log(error.message);
-            return 130;
-        }
-        if (error instanceof ConfigurationError)
-            throw error;
         if (error instanceof Error) {
             printError(error.message);
             return 2;
         }
         throw error;
     }
+    try {
+        return await continueLocked();
+    }
+    catch (error) {
+        if (isSessionLockLost(error)) {
+            printError(error.message);
+            return 2;
+        }
+        throw error;
+    }
     finally {
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
+        lock.release();
+    }
+    async function continueLocked() {
+        repairSessionUnlocked(workspace, args.sessionId);
+        const store = new SessionStore(workspace);
+        const status = store.readSessionStatus(args.sessionId);
+        const sessionStatus = typeof status.status === "string" ? status.status : "";
+        const role = typeof status.role === "string" ? status.role : "";
+        if (role === "")
+            throw new ConfigurationError(`Session ${args.sessionId} has no role.`);
+        if (sessionStatus === "completed" && args.reply === null) {
+            printNotice(`Session ${args.sessionId} is completed.`);
+            return 0;
+        }
+        if (sessionStatus === "cancelled" && args.reply !== null) {
+            throw new ConfigurationError(`Session ${args.sessionId} was cancelled. session continue resumes that execution. Omit --reply.`);
+        }
+        const latest = store.latestExecution(args.sessionId);
+        if (latest === null)
+            throw new ConfigurationError(`Session ${args.sessionId} has no execution.`);
+        const profile = executionProfile(latest.directory, latest.executionId);
+        const optionLabel = Object.entries(profile.options)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join(", ") || "default";
+        printNotice(`agent ${role} · ${profile.provider}/${profile.model} (${optionLabel}).`);
+        const unbind = bindCancellationSignals();
+        try {
+            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            if (sessionStatus === "cancelled") {
+                return await runCancelledRole(workspace, args.sessionId, role, profile, runner, false, args.waitHooks);
+            }
+            let prompt;
+            if (args.reply !== null) {
+                prompt = rolePrompt(workspace, role, args.reply);
+            }
+            else if (sessionStatus === "blocked") {
+                const blocker = executionBlocker(latest.directory);
+                const resumed = store.resumeBlockedSession(args.sessionId);
+                for (const item of resumed) {
+                    log(`session ${args.sessionId} was blocked by ${item.executionId}. Resuming ${role}.`);
+                }
+                const lines = ["Previous attempt:", `- execution: ${latest.executionId}`];
+                if (blocker)
+                    lines.push(`- blocker: ${blocker}`);
+                lines.push("That attempt ended blocked. The blocker was handled outside this session. Continue.");
+                prompt = rolePrompt(workspace, role, lines.join("\n"));
+            }
+            else if (sessionStatus === "active") {
+                log(`session ${args.sessionId} is active. Resuming ${role} with its last prompt.`);
+                prompt = lastUserPrompt(workspace, args.sessionId, latest.executionId);
+            }
+            else {
+                throw new ConfigurationError(`Session ${args.sessionId} is ${sessionStatus || "unknown"}.`);
+            }
+            const waitedUntil = new Map();
+            const rerun = (nextPrompt, resumeId) => runner.run({
+                provider: profile.provider,
+                model: profile.model,
+                options: { ...profile.options },
+                prompt: nextPrompt,
+                workspace,
+                sessionId: args.sessionId,
+                resumeExecutionId: resumeId,
+                stageId: role,
+            });
+            const result = await rerunQuota(workspace, args.sessionId, await rerun(prompt, latest.executionId), () => prompt, rerun, waitedUntil, args.waitHooks);
+            printAgent({ ...result }, role, profile.provider, profile.model);
+            return finishRole(args.sessionId, result.outcome_status === "complete" ? 0 : 1);
+        }
+        catch (error) {
+            if (error instanceof CancellationRequested) {
+                log(error.message);
+                return finishRole(args.sessionId, 130);
+            }
+            if (error instanceof ConfigurationError)
+                throw error;
+            if (error instanceof Error) {
+                printError(error.message);
+                return 2;
+            }
+            throw error;
+        }
+        finally {
+            unbind();
+        }
+    }
+}
+async function runCancelledRole(workspace, sessionId, role, profile, runner, asJson, waitHooks) {
+    const reopened = new SessionStore(workspace).reopenCancelledExecutions(sessionId);
+    for (const item of reopened) {
+        log(`session ${sessionId} was cancelled during ${item.executionId}. Resuming that execution.`);
+    }
+    const waitedUntil = new Map();
+    const rerun = (prompt, resumeId) => runner.run({
+        provider: profile.provider,
+        model: profile.model,
+        options: { ...profile.options },
+        prompt,
+        workspace,
+        sessionId,
+        resumeExecutionId: resumeId,
+        stageId: role,
+    });
+    const settled = await Promise.allSettled(reopened.map((item) => runner.continueCancelled(workspace, sessionId, item.executionId)));
+    const rejected = settled.find((item) => item.status === "rejected");
+    if (rejected && rejected.status === "rejected")
+        throw rejected.reason;
+    const continued = settled.flatMap((item) => (item.status === "fulfilled" ? [item.value] : []));
+    if (continued.length === 0) {
+        throw new ConfigurationError(`Session ${sessionId} is cancelled without an execution.`);
+    }
+    const finished = [];
+    for (const item of continued) {
+        finished.push(await rerunQuota(workspace, sessionId, item, (current) => lastUserPrompt(workspace, sessionId, current.execution_id), rerun, waitedUntil, waitHooks));
+    }
+    if (finished.length === 1) {
+        const result = finished[0];
+        if (result === undefined)
+            throw new Error("Agent run produced no result.");
+        if (asJson)
+            process.stdout.write(`${JSON.stringify(result)}\n`);
+        else
+            printAgent({ ...result }, role, profile.provider, profile.model);
+        return finishRole(sessionId, result.outcome_status === "complete" ? 0 : 1);
+    }
+    if (asJson)
+        process.stdout.write(`${JSON.stringify(finished)}\n`);
+    else {
+        for (const item of finished)
+            printAgent({ ...item }, role, profile.provider, profile.model);
+    }
+    if (finished.some((item) => item.failure_reason === "verify_exhausted"))
+        return finishRole(sessionId, 6);
+    return finishRole(sessionId, finished.every((item) => item.outcome_status === "complete") ? 0 : 1);
+}
+async function rerunQuota(workspace, sessionId, initial, promptFor, run, waitedUntil, hooks) {
+    let current = initial;
+    let armed = null;
+    while (current.failure_kind === "quota" && current.reset_at !== "") {
+        if (armed !== null && !laterInstant(current.reset_at, armed))
+            return current;
+        const resetAt = current.reset_at;
+        const provider = current.provider;
+        const shared = waitedUntil.get(provider);
+        const now = hooks?.now ?? Date.now;
+        const past = !Number.isFinite(Date.parse(resetAt)) || now() >= Date.parse(resetAt);
+        if (!past && (shared === undefined || laterInstant(resetAt, shared))) {
+            emitRoleQuota(workspace, sessionId, current);
+            await waitUntil(resetAt, hooks).promise;
+        }
+        waitedUntil.set(provider, resetAt);
+        armed = resetAt;
+        current = await run(promptFor(current), current.execution_id);
+    }
+    return current;
+}
+function laterInstant(next, previous) {
+    const left = Date.parse(next);
+    const right = Date.parse(previous);
+    if (Number.isFinite(left) && Number.isFinite(right))
+        return left > right;
+    return next > previous;
+}
+function emitRoleQuota(workspace, sessionId, result) {
+    const store = new SessionStore(workspace);
+    const context = store.executionContext(sessionId, result.execution_id);
+    if (context === null)
+        return;
+    let model = "";
+    try {
+        const metadata = JSON.parse(readFileSync(path.join(context.directory, "execution.json"), "utf8"));
+        if (isRecord(metadata) && typeof metadata.model === "string")
+            model = metadata.model;
+    }
+    catch {
+        model = "";
+    }
+    const summary = [result.response, result.reset_at].filter((item) => item !== "").join(" ");
+    new ProviderEventReporter(store, context, result.provider, model).emit("provider.quota", summary, {
+        retry_at: result.reset_at,
+        provider: result.provider,
+    });
+}
+function lastUserPrompt(workspace, sessionId, executionId) {
+    const context = new SessionStore(workspace).executionContext(sessionId, executionId);
+    if (context === null)
+        throw new ConfigurationError(`Execution ${executionId} was not found.`);
+    const raw = JSON.parse(readFileSync(context.conversationReadPath, "utf8"));
+    const history = Array.isArray(raw) ? raw : isRecord(raw) && Array.isArray(raw.history) ? raw.history : [];
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const entry = history[index];
+        if (isRecord(entry) && entry.role === "user" && typeof entry.content === "string" && entry.content !== "") {
+            return entry.content;
+        }
+    }
+    throw new ConfigurationError(`Execution ${executionId} has no prompt to resume.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finishRole(sessionId, code) {
+    if (code === 1 || code === 6 || code === 130)
+        printResumeCommand(sessionId);
+    return code;
+}
+function rolePrompt(workspace, role, text) {
+    return prependRoleInstructions(loadRoleInstructions(loadYamlMapping(path.join(workspace, ".migent", "config.yaml")), role), text);
+}
+function executionProfile(directory, executionId) {
+    const raw = JSON.parse(readFileSync(path.join(directory, "execution.json"), "utf8"));
+    if (!isRecord(raw) ||
+        typeof raw.provider !== "string" ||
+        raw.provider === "" ||
+        typeof raw.model !== "string" ||
+        raw.model === "") {
+        throw new ConfigurationError(`Execution ${executionId} has no provider.`);
+    }
+    return { provider: raw.provider, model: raw.model, options: stringOptions(raw.options) };
+}
+function executionBlocker(directory) {
+    try {
+        const raw = JSON.parse(readFileSync(path.join(directory, "execution.json"), "utf8"));
+        if (!isRecord(raw) || !isRecord(raw.outcome))
+            return null;
+        return typeof raw.outcome.blocker === "string" && raw.outcome.blocker !== "" ? raw.outcome.blocker : null;
+    }
+    catch {
+        return null;
     }
-    if (createdSession)
-        printNotice(`session_id: ${result.session_id}`);
-    if (args.asJson)
-        process.stdout.write(`${JSON.stringify(result)}\n`);
-    else
-        printAgent({ ...result }, args.role, target.provider, target.model);
-    return result.outcome_status === "complete" ? 0 : 1;
 }
 function resolveSession(workspace, sessionId, role, task) {
     if (sessionId !== null && typeof task === "string" && task.trim() !== "") {

package/dist/commands/config.js

@@ -1,8 +1,9 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { confirm as clackConfirm, isCancel, select as clackSelect, text as clackText } from "@clack/prompts";
-import { ConfigEditError, ConfigurationError, assignRoles, describeChange, diagnose, inspectConfig, loadModelTarget, loadWorkflowCatalog, loadYamlMapping, matchingModelName, patchConfigText, placeRoleModel, resolveStageSpec, setRoleOptions, upsertModel, whichSync, } from "@nodeint/migent-kernel";
+import { ConfigEditError, ConfigurationError, assignRoles, describeChange, diagnose, inspectConfig, loadModelTarget, loadWorkflowCatalog, loadYamlMapping, matchingModelName, patchConfigText, placeRoleModel, isRoleStage, resolveStageSpec, setRoleOptions, upsertModel, whichSync, } from "@nodeint/migent-kernel";
 import { printError } from "../display.js";
+import { PromptCancelled } from "../errors.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
 import { acceptedOptions, adapterMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireAdapter, runProviderCommand, } from "../provider.js";
@@ -25,6 +26,8 @@ export async function runConfigModel(workspace, options = {}) {
         });
     }
     catch (error) {
+        if (error instanceof PromptCancelled)
+            throw error;
         if (error instanceof ConfigurationError || error instanceof ConfigEditError || error instanceof Error) {
             printError(error.message);
             return 2;
@@ -43,6 +46,8 @@ export async function runConfigRole(workspace, options = {}) {
         });
     }
     catch (error) {
+        if (error instanceof PromptCancelled)
+            throw error;
         if (error instanceof ConfigurationError || error instanceof ConfigEditError || error instanceof Error) {
             printError(error.message);
             return 2;
@@ -311,6 +316,8 @@ function validateChange(before, after, workflows, adapters) {
     }
     for (const document of workflows) {
         for (const stage of Object.values(document.stages)) {
+            if (!isRoleStage(stage))
+                continue;
             let beforeTarget;
             let afterTarget;
             try {
@@ -382,7 +389,7 @@ function optionUpdatesOf(options, clearOptions) {
 async function selectProvider(prompter, adapters, which, message, defaultValue) {
     const rows = detected(adapters, which);
     if (rows.length === 0)
-        throw new Error("No providers are available.");
+        throw new ConfigurationError("No providers are available.");
     const names = new Set(rows.map(([name]) => name));
     return prompter.select(message, rows.map(([name, found]) => [`${name}  ${found ?? "not found"}`, name]), defaultValue !== null && names.has(defaultValue) ? defaultValue : rows[0]?.[0]);
 }
@@ -486,6 +493,7 @@ function roleJson(role) {
         provider: role.provider,
         model: role.model,
         options: { ...role.options },
+        instructions: [...role.instructions],
         shared_with: [...role.sharedWith],
         stages: role.stages.map((stage) => ({
             workflow: stage.workflow,
@@ -586,7 +594,7 @@ function isRecord(value) {
 class ClackConfigPrompter {
     async select(message, choices, defaultValue) {
         if (choices.length === 0)
-            throw new Error("Choose a value.");
+            throw new ConfigurationError("Choose a value.");
         const values = new Set(choices.map(([, value]) => value));
         const initial = defaultValue != null && values.has(defaultValue) ? defaultValue : choices[0]?.[1];
         const result = await clackSelect({
@@ -594,20 +602,26 @@ class ClackConfigPrompter {
             options: choices.map(([label, value]) => ({ label, value })),
             initialValue: initial,
         });
-        if (isCancel(result) || typeof result !== "string" || !values.has(result))
-            throw new Error("Choose a value.");
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (typeof result !== "string" || !values.has(result))
+            throw new ConfigurationError("Choose a value.");
         return result;
     }
     async confirm(message) {
         const result = await clackConfirm({ message, initialValue: true });
-        if (isCancel(result) || typeof result !== "boolean")
-            throw new Error("Answer yes or no.");
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (typeof result !== "boolean")
+            throw new ConfigurationError("Answer yes or no.");
         return result;
     }
     async text(message, defaultValue = "") {
         const result = await clackText({ message, initialValue: defaultValue });
-        if (isCancel(result) || typeof result !== "string")
-            throw new Error("Enter a value.");
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (typeof result !== "string")
+            throw new ConfigurationError("Enter a value.");
         return result;
     }
 }

package/dist/commands/execute.d.ts

@@ -5,8 +5,13 @@ export interface ExecuteWorkflowOptions {
     task?: string | null;
     sessionId?: string | null;
     priorSessionId?: string | null;
-    maxAttempts?: number | null;
     maxDispatches?: number | null;
+    continueFailed?: boolean;
+    stageId?: string | null;
     runner?: AgentToolRunner | null;
+    itemProgress?: boolean;
+    startPrepared?: boolean;
+    refreshWorkflow?: boolean;
+    reply?: string | null;
 }
 export declare function executeWorkflow(workspace: string, options: ExecuteWorkflowOptions): Promise<number>;