opencode-magi 0.0.0-dev-20260721051539 → 0.0.0-dev-20260722060754

package/dist/magi.js

@@ -217,27 +217,69 @@ export class Magi {
         }
     }
     async promptSession(sessionID, text, signal) {
-        const result = await this.input.client.session.prompt({
-            parts: [{ text, type: "text" }],
-            sessionID,
-        }, { signal });
-        if (result.error) {
-            if (!isUndefined(result.response) && result.response.statusText)
-                throw new Error(result.response.statusText);
-            else if (result.error instanceof Error)
-                throw new Error(result.error.message);
-            else
-                throw new Error(JSON.stringify(result.error));
+        const controller = new AbortController();
+        const events = await this.input.client.event.subscribe(undefined, {
+            signal: controller.signal,
+        });
+        try {
+            const result = await Promise.race([
+                this.input.client.session.prompt({
+                    parts: [{ text, type: "text" }],
+                    sessionID,
+                }, { signal }),
+                this.monitorSession(sessionID, events.stream),
+            ]);
+            if (result.error) {
+                if (!isUndefined(result.response) && result.response.statusText)
+                    throw new Error(result.response.statusText);
+                else if (result.error instanceof Error)
+                    throw new Error(result.error.message);
+                else
+                    throw new Error(JSON.stringify(result.error));
+            }
+            else {
+                const output = result.data.parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n");
+                if (!output)
+                    throw new Error("OpenCode session.prompt did not return text output.");
+                return output;
+            }
         }
-        else {
-            const output = result.data.parts
-                .filter((part) => part.type === "text")
-                .map((part) => part.text)
-                .join("\n");
-            if (!output)
-                throw new Error("OpenCode session.prompt did not return text output.");
-            return output;
+        catch (e) {
+            if (e instanceof MagiError)
+                await this.input.client.session.abort({ sessionID });
+            throw e;
+        }
+        finally {
+            controller.abort();
+        }
+    }
+    async monitorSession(sessionID, events) {
+        for await (const ev of events) {
+            if (ev.type === "permission.asked" &&
+                ev.properties.sessionID === sessionID) {
+                const { id, patterns, permission } = ev.properties;
+                const result = await this.input.client.permission.reply({
+                    reply: "reject",
+                    requestID: id,
+                });
+                if (result.error)
+                    throw new MagiError("blocked", "Could not reject permission request.");
+                throw new MagiError("blocked", `OpenCode session requested ${permission} permission for ${patterns.join(", ")}.`);
+            }
+            if (ev.type === "question.asked" &&
+                ev.properties.sessionID === sessionID) {
+                const result = await this.input.client.question.reject({
+                    requestID: ev.properties.id,
+                });
+                if (result.error)
+                    throw new MagiError("blocked", "Could not reject user question.");
+                throw new MagiError("blocked", "OpenCode session requested user input.");
+            }
         }
+        return new Promise(() => { });
     }
     async deleteSessions(state) {
         const sessionIds = this.getSessionIds(state);

package/dist/prompts/index.js

@@ -1,7 +1,7 @@
 import Ajv from "ajv";
 import { readFile } from "fs/promises";
 import { join } from "path";
-import { isString } from "@/utils";
+import { isString, isUndefined } from "@/utils";
 export class Prompt {
     magi;
     config;
@@ -43,11 +43,16 @@ export class Prompt {
         ].join("\n\n");
         return Object.entries(values).reduce((prev, [key, value]) => prev.replaceAll(`{${key}}`, value), content);
     }
-    async repair() {
+    async repair(e) {
         const instructions = [
-            "Your previous output did not match the required schema. Regenerate the result.",
+            "Your previous output failed validation. Regenerate the result.",
+            !isUndefined(e)
+                ? `Validation error: ${e instanceof Error ? e.message : "Invalid output."}`
+                : undefined,
             "Return only a JSON object matching the output contract below. Do not include analysis, explanation, apologies, markdown, or any text before or after the JSON object.",
-        ].join("\n\n");
+        ]
+            .filter((instruction) => !isUndefined(instruction))
+            .join("\n\n");
         try {
             const outputContract = await readFile(join(this.pathname, "output-contract.md"), "utf-8");
             return [

package/dist/tools/merge/action.js

@@ -1,10 +1,10 @@
 import { MagiError } from "@/magi";
 import { retry } from "@/utils";
-export async function editCycles(callback) {
+export async function editCycles(cb) {
     this.context.abort.throwIfAborted();
     const error = new Error("Continue edit cycle.");
     const verdict = await retry(async (cycle) => {
-        const verdict = await callback(cycle);
+        const verdict = await cb(cycle);
         if (verdict === "CHANGES_REQUESTED")
             throw error;
         return verdict;

package/dist/tools/merge/editor.js

@@ -23,9 +23,8 @@ export async function edit() {
         repo: this.config.github.repo,
         worktreePath: this.state.worktree.path,
     });
-    const repairMessage = await prompt.repair();
-    const output = await retry(async (count) => {
-        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+    const output = await retry(async (count, e) => {
+        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
         await this.createAgentFile("edit", "editor", raw, count, cycle);
         const parsed = prompt.parse(raw);
         if (!prompt.validate(parsed))
@@ -44,7 +43,11 @@ export async function edit() {
         }
         return output;
     }, {
-        error: (_, count) => this.updateEvent(`Attempt ${count} failed to edit. Retrying...`),
+        error: async (e, count) => {
+            if (e instanceof MagiError)
+                throw e;
+            await this.updateEvent(`Attempt ${count} failed to edit. Retrying...`);
+        },
         retries: this.config.output.repairAttempts,
         signal: this.context.abort,
     });
@@ -111,9 +114,8 @@ export async function resolveConflict() {
         repo: this.config.github.repo,
         worktreePath: this.state.worktree.path,
     });
-    const repairMessage = await prompt.repair();
-    const output = await retry(async (count) => {
-        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+    const output = await retry(async (count, e) => {
+        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
         await this.createAgentFile("conflict", "editor", raw, count, cycle);
         const parsed = prompt.parse(raw);
         if (!prompt.validate(parsed))
@@ -136,7 +138,11 @@ export async function resolveConflict() {
             responses: [],
         };
     }, {
-        error: (_, count) => this.updateEvent(`Attempt ${count} failed to resolve conflicts. Retrying...`),
+        error: async (e, count) => {
+            if (e instanceof MagiError)
+                throw e;
+            await this.updateEvent(`Attempt ${count} failed to resolve conflicts. Retrying...`);
+        },
         retries: this.config.output.repairAttempts,
         signal: this.context.abort,
     });

package/dist/tools/review/action.js

@@ -78,16 +78,19 @@ export async function postReviews() {
                 repo: this.config.github.repo,
                 verdict: this.state.pr.verdict,
             });
-            const repairMessage = await prompt.repair();
-            const output = await retry(async (count) => {
-                const raw = await this.magi.promptSession(this.state.operator.sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+            const output = await retry(async (count, e) => {
+                const raw = await this.magi.promptSession(this.state.operator.sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
                 await this.createAgentFile("comment", "operator", raw, count);
                 const parsed = prompt.parse(raw);
                 if (!prompt.validate(parsed))
                     throw new Error("Invalid output for operator.");
                 return parsed.comment;
             }, {
-                error: (_, count) => this.updateEvent(`Attempt ${count} failed to post comment by operator. Retrying...`),
+                error: async (e, count) => {
+                    if (e instanceof MagiError)
+                        throw e;
+                    await this.updateEvent(`Attempt ${count} failed to post comment by operator. Retrying...`);
+                },
                 retries: this.config.output.repairAttempts,
                 signal: this.context.abort,
             });

package/dist/tools/review/check.js

@@ -101,20 +101,23 @@ export async function classifyChecks() {
         repo: this.config.github.repo,
         worktreePath: this.state.worktree.path,
     });
-    const repairMessage = await prompt.repair();
     await Promise.all(Object.entries(this.state.reviewers ?? {}).map(([id, { sessionId }]) => worker.run(async () => {
         if (!sessionId)
             throw new Error(`No session ID found for reviewer ${id}.`);
         await this.updateEvent(`Classifying CI checks with reviewer ${id}.`);
-        const output = await retry(async (count) => {
-            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+        const output = await retry(async (count, e) => {
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
             await this.createAgentFile("ci-classification", id, raw, count);
             const parsed = prompt.parse(raw);
             if (!prompt.validate(parsed))
                 throw new Error(`Invalid output for reviewer ${id}.`);
             return parsed;
         }, {
-            error: (_, count) => this.updateEvent(`Attempt ${count} failed to classify CI checks with reviewer ${id}. Retrying...`),
+            error: async (e, count) => {
+                if (e instanceof MagiError)
+                    throw e;
+                await this.updateEvent(`Attempt ${count} failed to classify CI checks with reviewer ${id}. Retrying...`);
+            },
             retries: this.config.output.repairAttempts,
             signal: this.context.abort,
         });

package/dist/tools/review/reviewer.js

@@ -70,10 +70,10 @@ export async function review() {
                 }), null, 2);
                 tags.push(["previous_review", previousReviewContext]);
             }
-            if (unresolvedThreads.length) {
-                const unresolvedThreadsContext = JSON.stringify(unresolvedThreads, null, 2);
-                tags.push(["unresolved_threads", unresolvedThreadsContext]);
-            }
+            tags.push([
+                "unresolved_threads",
+                JSON.stringify(unresolvedThreads, null, 2),
+            ]);
             if (failedChecks.length) {
                 const ciFailureContext = JSON.stringify(failedChecks, null, 2);
                 tags.push(["ci_failure", ciFailureContext]);
@@ -94,9 +94,8 @@ export async function review() {
                 repo: this.config.github.repo,
                 worktreePath: this.state.worktree.path,
             }));
-            const repairMessage = await prompt.repair();
-            const output = await retry(async (count) => {
-                const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+            const output = await retry(async (count, e) => {
+                const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
                 await this.createAgentFile(rereview ? "rereview" : "review", id, raw, count, cycle);
                 const parsed = prompt.parse(raw);
                 if (!prompt.validate(parsed))
@@ -126,7 +125,11 @@ export async function review() {
                 ]).join("\n\n"));
                 return parsed;
             }, {
-                error: (_, count) => this.updateEvent(`Attempt ${count} failed to ${label} with reviewer ${id}. Retrying...`),
+                error: async (e, count) => {
+                    if (e instanceof MagiError)
+                        throw e;
+                    await this.updateEvent(`Attempt ${count} failed to ${label} with reviewer ${id}. Retrying...`);
+                },
                 retries: this.config.output.repairAttempts,
                 signal: this.context.abort,
             });
@@ -199,10 +202,9 @@ export async function reconsiderClose() {
             pr: this.number.toString(),
             repo: this.config.github.repo,
         });
-        const repairMessage = await prompt.repair();
         await this.updateEvent(`Reconsidering close verdict with reviewer ${id}.`);
-        const output = await retry(async (count) => {
-            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+        const output = await retry(async (count, e) => {
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
             await this.createAgentFile("close-reconsideration", id, raw, count, cycle);
             const parsed = prompt.parse(raw);
             if (!prompt.validate(parsed))
@@ -210,7 +212,11 @@ export async function reconsiderClose() {
             validateInlineCommentTargets("initial", parsed, inlineCommentTargets);
             return parsed;
         }, {
-            error: (_, count) => this.updateEvent(`Attempt ${count} failed to reconsider close verdict with reviewer ${id}. Retrying...`),
+            error: async (e, count) => {
+                if (e instanceof MagiError)
+                    throw e;
+                await this.updateEvent(`Attempt ${count} failed to reconsider close verdict with reviewer ${id}. Retrying...`);
+            },
             retries: this.config.output.repairAttempts,
             signal: this.context.abort,
         });
@@ -267,9 +273,8 @@ async function collectAcceptedFindings(findings) {
             pr: this.number.toString(),
             repo: this.config.github.repo,
         });
-        const repairMessage = await prompt.repair();
-        const output = await retry(async (count) => {
-            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
+        const output = await retry(async (count, e) => {
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
             await this.createAgentFile("finding-validation", id, raw, count);
             const parsed = prompt.parse(raw);
             if (!prompt.validate(parsed))
@@ -290,7 +295,11 @@ async function collectAcceptedFindings(findings) {
                     throw new Error(`Missing finding vote: ${key}.`);
             return parsed;
         }, {
-            error: (_, count) => this.updateEvent(`Attempt ${count} failed to validate review findings with reviewer ${id}. Retrying...`),
+            error: async (e, count) => {
+                if (e instanceof MagiError)
+                    throw e;
+                await this.updateEvent(`Attempt ${count} failed to validate review findings with reviewer ${id}. Retrying...`);
+            },
             retries: this.config.output.repairAttempts,
             signal: this.context.abort,
         });
@@ -386,12 +395,15 @@ function validateInlineCommentTargets(status, output, inlineCommentTargets) {
 }
 function validateThreadTargets({ followUps, resolves }, threads) {
     const targets = new Map(threads.flatMap(({ comments, id }) => comments.flatMap(({ databaseId }) => databaseId == null ? [] : [[databaseId, id]])));
+    const allowedTargets = [...targets.entries()]
+        .map(([commentId, threadId]) => `- ${commentId}:${threadId}`)
+        .join("\n") || "none";
     if (followUps)
         for (const [index, { commentId }] of followUps.entries())
             if (!targets.has(commentId))
-                throw new Error(`followUps[${index}].commentId must target an unresolved thread owned by the reviewer.`);
+                throw new Error(`followUps[${index}].commentId must target an unresolved thread owned by the reviewer.\n\nAllowed targets:\n${allowedTargets}`);
     if (resolves)
         for (const [index, { commentId, threadId }] of resolves.entries())
             if (targets.get(commentId) !== threadId)
-                throw new Error(`resolves[${index}] must target an unresolved thread owned by the reviewer.`);
+                throw new Error(`resolves[${index}] must target an unresolved thread owned by the reviewer.\n\nAllowed targets:\n${allowedTargets}`);
 }

package/dist/utils/function.js

@@ -12,24 +12,26 @@ export function wait(ms = 0, signal) {
         signal?.addEventListener("abort", abort, { once: true });
     });
 }
-export async function loop(callback, ms = 0) {
+export async function loop(cb, ms = 0) {
     for (;;) {
-        const value = await callback();
+        const value = await cb();
         if (value != null)
             return value;
         await wait(ms);
     }
 }
-export async function retry(callback, { error, retries = 1, signal }) {
+export async function retry(cb, { error: errorCb, retries = 1, signal }) {
     let count = 1;
+    let error;
     while (count <= retries)
         try {
             signal?.throwIfAborted();
-            return await callback(count);
+            return await cb(count, error);
         }
         catch (e) {
             signal?.throwIfAborted();
-            await error?.(e, count);
+            await errorCb?.(e, count);
+            error = e;
             count += 1;
         }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260721051539",
+  "version": "0.0.0-dev-20260722060754",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",