@nodeint/migent 0.1.5 → 0.1.7

package/dist/commands/agent.js

@@ -1,10 +1,11 @@
+import { readFileSync } from "node:fs";
 import path from "node:path";
-import { AgentToolRunner, CancellationRequested, ConfigurationError, createAgentSession, loadRoleInstructions, loadYamlMapping, log, prependRoleInstructions, requireAgentSession, isSessionLockLost, repairSessionUnlocked, SessionLock, resolveRoleTarget, SessionStore, } from "@nodeint/migent-kernel";
-import { printAgent, printError, printNotice } from "../display.js";
+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 { providerMap, parseOptions } from "../provider.js";
 import { resolvePrompt } from "../workspace.js";
 export async function dispatchAgent(workspace, args) {
     requireCurrentSchema(workspace);
@@ -64,7 +65,18 @@ export async function dispatchAgent(workspace, args) {
         let result;
         let resumedMany = null;
         try {
-            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(providerMap());
+            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) {
@@ -78,32 +90,37 @@ export async function dispatchAgent(workspace, args) {
                 if (continued.length === 0) {
                     throw new ConfigurationError(`Session ${resolvedSessionId} is cancelled without an execution.`);
                 }
-                if (continued.length === 1)
-                    result = continued[0];
+                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 = continued;
+                    resumedMany = finished;
             }
             else {
-                result = await runner.run({
+                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: prependRoleInstructions(loadRoleInstructions(loadYamlMapping(path.join(workspace, ".migent", "config.yaml")), args.role), resolvePrompt({
-                        prompt: args.prompt ?? null,
-                        promptFile: args.promptFile ?? null,
-                        promptStdin: args.promptStdin ?? false,
-                    })),
+                    prompt,
                     workspace,
                     sessionId: resolvedSessionId,
                     resumeExecutionId,
                     stageId: args.role,
-                });
+                }), () => prompt, rerun, waitedUntil, args.waitHooks);
             }
         }
         catch (error) {
             if (error instanceof CancellationRequested) {
                 log(error.message);
-                return 130;
+                return finishRole(resolvedSessionId, 130);
             }
             if (error instanceof ConfigurationError)
                 throw error;
@@ -123,9 +140,10 @@ export async function dispatchAgent(workspace, args) {
                 for (const item of resumedMany)
                     printAgent({ ...item }, args.role, target.provider, target.model);
             }
-            if (resumedMany.some((item) => item.failure_reason === "verify_exhausted"))
-                return 6;
-            return resumedMany.every((item) => item.outcome_status === "complete") ? 0 : 1;
+            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.");
@@ -133,7 +151,262 @@ export async function dispatchAgent(workspace, args) {
             process.stdout.write(`${JSON.stringify(result)}\n`);
         else
             printAgent({ ...result }, args.role, target.provider, target.model);
-        return result.outcome_status === "complete" ? 0 : 1;
+        return finishRole(resolvedSessionId, result.outcome_status === "complete" ? 0 : 1);
+    }
+}
+export async function continueAgent(workspace, args) {
+    requireCurrentSchema(workspace);
+    requireAgentSession(workspace, args.sessionId);
+    let lock;
+    try {
+        lock = SessionLock.acquire(path.join(workspace, ".migent", "sessions", args.sessionId));
+    }
+    catch (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 {
+        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(providerMap());
+            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;
     }
 }
 function resolveSession(workspace, sessionId, role, task) {

package/dist/commands/config.d.ts

@@ -1,4 +1,4 @@
-import { type AgentAdapter } from "@nodeint/migent-kernel";
+import { type Provider } from "@nodeint/migent-kernel";
 import { type RunCommand, type Which } from "../provider.js";
 export interface ConfigPrompter {
     select(message: string, choices: ReadonlyArray<readonly [string, string]>, defaultValue?: string | null): string | Promise<string>;
@@ -14,7 +14,7 @@ export declare function runConfigModel(workspace: string, options?: {
     clearOptions?: readonly string[];
     asJson?: boolean;
     interactive?: boolean;
-    adapters?: Record<string, AgentAdapter> | null;
+    providers?: Record<string, Provider> | null;
     which?: Which | null;
     prompter?: ConfigPrompter | null;
     runCommand?: RunCommand | null;
@@ -28,7 +28,7 @@ export declare function runConfigRole(workspace: string, options?: {
     clearOptions?: readonly string[];
     asJson?: boolean;
     interactive?: boolean;
-    adapters?: Record<string, AgentAdapter> | null;
+    providers?: Record<string, Provider> | null;
     which?: Which | null;
     prompter?: ConfigPrompter | null;
     runCommand?: RunCommand | null;