opencode-copilot-account-switcher 0.2.7 → 0.2.8

package/dist/copilot-network-retry.js

@@ -13,7 +13,7 @@ const RETRYABLE_MESSAGES = [
     "unable to verify the first certificate",
     "self-signed certificate in certificate chain",
 ];
-const MAX_INPUT_ID_REPAIR_ATTEMPTS = 3;
+const INPUT_ID_REPAIR_HARD_LIMIT = 64;
 const INTERNAL_SESSION_HEADER = "x-opencode-session-id";
 const defaultDebugLogFile = (() => {
     const tmp = process.env.TEMP || process.env.TMP || "/tmp";
@@ -70,6 +70,9 @@ function parseInputIdTooLongDetails(text) {
 function buildIdPreview(id) {
     return `${id.slice(0, 12)}...`;
 }
+function buildMessagePreview(message) {
+    return message.slice(0, 160);
+}
 function getPayloadCandidates(payload) {
     const input = payload.input;
     if (!Array.isArray(input))
@@ -89,33 +92,52 @@ function hasLongInputIds(payload) {
         return false;
     return input.some((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
 }
-function getTargetedLongInputId(payload, reportedLength) {
+function countLongInputIdCandidates(payload) {
+    const input = payload?.input;
+    if (!Array.isArray(input))
+        return 0;
+    return input.filter((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64)
+        .length;
+}
+function collectLongInputIdCandidates(payload) {
     const input = payload.input;
     if (!Array.isArray(input))
-        return undefined;
-    const matches = input.filter((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
+        return [];
+    return input.flatMap((item, payloadIndex) => {
+        const id = item?.id;
+        if (typeof id !== "string" || id.length <= 64)
+            return [];
+        return [{ item: item, payloadIndex, idLength: id.length }];
+    });
+}
+function pickCandidateByServerIndexHint(candidates, serverReportedIndex) {
+    const hintedPayloadIndex = serverReportedIndex - 1;
+    return candidates
+        .filter((candidate) => candidate.payloadIndex >= hintedPayloadIndex)
+        .sort((left, right) => left.payloadIndex - right.payloadIndex)[0];
+}
+function getTargetedLongInputId(payload, serverReportedIndex, reportedLength) {
+    const matches = collectLongInputIdCandidates(payload);
     if (matches.length === 0)
         return undefined;
     const lengthMatches = reportedLength
-        ? matches.filter((item) => String(item.id ?? "").length === reportedLength)
+        ? matches.filter((item) => item.idLength === reportedLength)
         : matches;
     if (lengthMatches.length === 1)
-        return lengthMatches[0];
-    if (lengthMatches.length > 1)
-        return lengthMatches[0];
+        return lengthMatches[0].item;
     if (matches.length === 1)
-        return matches[0];
-    return matches.reduce((best, item) => {
-        const bestLength = String(best.id ?? "").length;
-        const itemLength = String(item.id ?? "").length;
-        return itemLength > bestLength ? item : best;
-    }, matches[0]);
+        return matches[0].item;
+    const narrowedCandidates = lengthMatches.length > 0 ? lengthMatches : matches;
+    if (typeof serverReportedIndex === "number") {
+        return pickCandidateByServerIndexHint(narrowedCandidates, serverReportedIndex)?.item;
+    }
+    return undefined;
 }
-function stripTargetedLongInputId(payload, reportedLength) {
+function stripTargetedLongInputId(payload, serverReportedIndex, reportedLength) {
     const input = payload.input;
     if (!Array.isArray(input))
         return payload;
-    const target = getTargetedLongInputId(payload, reportedLength);
+    const target = getTargetedLongInputId(payload, serverReportedIndex, reportedLength);
     if (!target)
         return payload;
     let changed = false;
@@ -177,8 +199,8 @@ function getHeader(request, init, name) {
         return request.headers.get(name) ?? undefined;
     return undefined;
 }
-function getTargetedInputId(payload, reportedLength) {
-    const target = getTargetedLongInputId(payload, reportedLength);
+function getTargetedInputId(payload, serverReportedIndex, reportedLength) {
+    const target = getTargetedLongInputId(payload, serverReportedIndex, reportedLength);
     const id = target?.id;
     if (typeof id !== "string")
         return undefined;
@@ -247,30 +269,61 @@ async function repairSessionPart(sessionID, failingId, ctx) {
         body: JSON.stringify(body),
     };
     if (ctx?.patchPart) {
-        await ctx.patchPart({ url: url.href, init });
+        try {
+            await ctx.patchPart({ url: url.href, init });
+            debugLog("input-id retry session repair", {
+                partID: match.partID,
+                messageID: match.messageID,
+                sessionID,
+            });
+            return true;
+        }
+        catch (error) {
+            debugLog("input-id retry session repair failed", {
+                partID: match.partID,
+                messageID: match.messageID,
+                sessionID,
+                error: String(error instanceof Error ? error.message : error),
+            });
+            return false;
+        }
+    }
+    try {
+        const response = await fetch(url, init);
         debugLog("input-id retry session repair", {
             partID: match.partID,
             messageID: match.messageID,
             sessionID,
+            ok: response.ok,
         });
-        return true;
+        if (!response.ok) {
+            debugLog("input-id retry session repair failed", {
+                partID: match.partID,
+                messageID: match.messageID,
+                sessionID,
+                status: response.status,
+            });
+        }
+        return response.ok;
+    }
+    catch (error) {
+        debugLog("input-id retry session repair failed", {
+            partID: match.partID,
+            messageID: match.messageID,
+            sessionID,
+            error: String(error instanceof Error ? error.message : error),
+        });
+        return false;
     }
-    const response = await fetch(url, init);
-    debugLog("input-id retry session repair", {
-        partID: match.partID,
-        messageID: match.messageID,
-        sessionID,
-        ok: response.ok,
-    });
-    return response.ok;
 }
 async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx, sessionID) {
-    if (response.status !== 400)
-        return { response, retried: false, nextInit: init };
+    if (response.status !== 400) {
+        return { response, retried: false, nextInit: init, retryState: undefined };
+    }
     const requestPayload = parseJsonBody(init);
     if (!requestPayload || !hasLongInputIds(requestPayload)) {
         debugLog("skip input-id retry: request has no long ids");
-        return { response, retried: false, nextInit: init };
+        return { response, retried: false, nextInit: init, retryState: undefined };
     }
     debugLog("input-id retry candidate", {
         status: response.status,
@@ -282,7 +335,7 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
         .catch(() => "");
     if (!responseText) {
         debugLog("skip input-id retry: empty response body");
-        return { response, retried: false, nextInit: init };
+        return { response, retried: false, nextInit: init, retryState: undefined };
     }
     let parsed = parseInputIdTooLongDetails(responseText);
     let matched = parsed.matched;
@@ -307,20 +360,21 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
         serverReportedIndex: parsed.serverReportedIndex,
         reportedLength: parsed.reportedLength,
     });
-    if (!matched)
-        return { response, retried: false, nextInit: init };
+    if (!matched) {
+        return { response, retried: false, nextInit: init, retryState: undefined };
+    }
     if (parsed.serverReportedIndex === undefined) {
         debugLog("skip input-id retry: missing server input index", {
             reportedLength: parsed.reportedLength,
         });
-        return { response, retried: false, nextInit: init };
+        return { response, retried: false, nextInit: init, retryState: undefined };
     }
     const payloadCandidates = getPayloadCandidates(requestPayload);
     debugLog("input-id retry payload candidates", {
         serverReportedIndex: parsed.serverReportedIndex,
         candidates: payloadCandidates,
     });
-    const failingId = getTargetedInputId(requestPayload, parsed.reportedLength);
+    const failingId = getTargetedInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     const targetedPayload = payloadCandidates.find((item) => item.idLength === parsed.reportedLength) ?? payloadCandidates[0];
     if (targetedPayload) {
         debugLog("input-id retry payload target", {
@@ -333,10 +387,20 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
     if (sessionID && failingId) {
         await repairSessionPart(sessionID, failingId, ctx).catch(() => false);
     }
-    const sanitized = stripTargetedLongInputId(requestPayload, parsed.reportedLength);
+    const sanitized = stripTargetedLongInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     if (sanitized === requestPayload) {
         debugLog("skip input-id retry: sanitize made no changes");
-        return { response, retried: false, nextInit: init };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            retryState: {
+                previousServerReportedIndex: parsed.serverReportedIndex,
+                previousErrorMessagePreview: buildMessagePreview(responseText),
+                remainingLongIdCandidatesBefore: countLongInputIdCandidates(requestPayload),
+                remainingLongIdCandidatesAfter: countLongInputIdCandidates(requestPayload),
+            },
+        };
     }
     debugLog("input-id retry triggered", {
         removedLongIds: true,
@@ -344,11 +408,17 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
     });
     const nextInit = buildRetryInit(init, sanitized);
     const retried = await baseFetch(request, nextInit);
+    const retryState = {
+        previousServerReportedIndex: parsed.serverReportedIndex,
+        previousErrorMessagePreview: buildMessagePreview(responseText),
+        remainingLongIdCandidatesBefore: countLongInputIdCandidates(requestPayload),
+        remainingLongIdCandidatesAfter: countLongInputIdCandidates(parseJsonBody(nextInit)),
+    };
     debugLog("input-id retry response", {
         status: retried.status,
         contentType: retried.headers.get("content-type") ?? undefined,
     });
-    return { response: retried, retried: true, nextInit };
+    return { response: retried, retried: true, nextInit, retryState };
 }
 function toRetryableSystemError(error) {
     const base = error instanceof Error ? error : new Error(String(error));
@@ -370,6 +440,37 @@ function isCopilotUrl(request) {
         return false;
     }
 }
+async function getInputIdRetryErrorDetails(response) {
+    if (response.status !== 400)
+        return undefined;
+    const responseText = await response
+        .clone()
+        .text()
+        .catch(() => "");
+    if (!responseText)
+        return undefined;
+    let parsed = parseInputIdTooLongDetails(responseText);
+    let matched = parsed.matched;
+    let message = responseText;
+    if (!matched) {
+        try {
+            const bodyPayload = JSON.parse(responseText);
+            const error = bodyPayload.error;
+            message = String(error?.message ?? "");
+            parsed = parseInputIdTooLongDetails(message);
+            matched = parsed.matched || isInputIdTooLongErrorBody(bodyPayload);
+        }
+        catch {
+            matched = false;
+        }
+    }
+    if (!matched)
+        return undefined;
+    return {
+        serverReportedIndex: parsed.serverReportedIndex,
+        errorMessagePreview: buildMessagePreview(message),
+    };
+}
 function withStreamDebugLogs(response, request) {
     if (!isDebugEnabled())
         return response;
@@ -443,12 +544,46 @@ export function createCopilotRetryingFetch(baseFetch, options) {
             if (isCopilotUrl(safeRequest)) {
                 let currentResponse = response;
                 let currentInit = effectiveInit;
-                for (let attempt = 0; attempt < MAX_INPUT_ID_REPAIR_ATTEMPTS; attempt += 1) {
+                let attempts = 0;
+                while (attempts < INPUT_ID_REPAIR_HARD_LIMIT) {
+                    const remainingCandidates = countLongInputIdCandidates(parseJsonBody(currentInit));
+                    if (remainingCandidates === 0)
+                        break;
                     const result = await maybeRetryInputIdTooLong(safeRequest, currentInit, currentResponse, baseFetch, options, sessionID);
                     currentResponse = result.response;
                     currentInit = result.nextInit;
+                    if (result.retryState) {
+                        const currentError = await getInputIdRetryErrorDetails(currentResponse);
+                        let stopReason;
+                        if (result.retryState.remainingLongIdCandidatesAfter >= result.retryState.remainingLongIdCandidatesBefore) {
+                            stopReason = "remaining-candidates-not-reduced";
+                        }
+                        else if (currentError) {
+                            const serverIndexChanged = result.retryState.previousServerReportedIndex !== currentError.serverReportedIndex;
+                            const errorMessageChanged = result.retryState.previousErrorMessagePreview !== currentError.errorMessagePreview;
+                            if (!serverIndexChanged && !errorMessageChanged) {
+                                stopReason = "server-error-unchanged";
+                            }
+                        }
+                        if (currentError || stopReason) {
+                            debugLog("input-id retry progress", {
+                                attempt: attempts + 1,
+                                previousServerReportedIndex: result.retryState.previousServerReportedIndex,
+                                currentServerReportedIndex: currentError?.serverReportedIndex,
+                                serverIndexChanged: result.retryState.previousServerReportedIndex !== currentError?.serverReportedIndex,
+                                previousErrorMessagePreview: result.retryState.previousErrorMessagePreview,
+                                currentErrorMessagePreview: currentError?.errorMessagePreview,
+                                remainingLongIdCandidatesBefore: result.retryState.remainingLongIdCandidatesBefore,
+                                remainingLongIdCandidatesAfter: result.retryState.remainingLongIdCandidatesAfter,
+                                stopReason,
+                            });
+                        }
+                        if (stopReason)
+                            break;
+                    }
                     if (!result.retried)
                         break;
+                    attempts += 1;
                 }
                 return withStreamDebugLogs(currentResponse, safeRequest);
             }

package/dist/loop-safety-plugin.d.ts

@@ -1,6 +1,6 @@
 import type { Hooks } from "@opencode-ai/plugin";
 import { type StoreFile } from "./store.js";
-export declare const LOOP_SAFETY_POLICY = "Guided Loop Safety Policy\n- Continue working on any remaining non-blocked task before stopping to report or wait for more instructions.\n- If you are not fully blocked, do not stop just because you feel ready to pause; finish the work that can still be done safely.\n- MANDATORY: When the question tool is available and permitted in the current session, ALL user-facing reports MUST be delivered through the question tool.\n- MANDATORY: Treat progress updates, status reports, summaries, explanations, completion notes, and next-step choices as user-facing reports.\n- MANDATORY: In this workflow, the question tool is both the question channel and the report channel for user-visible communication.\n- MANDATORY: Do not reinterpret \"keep working unless blocked\" as permission to send direct assistant text. If you need to report, report through the question tool.\n- MANDATORY: Do not reinterpret \"don't ask unnecessary questions\" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.\n- MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.\n- MANDATORY: When reflecting on mistakes, check report-channel violations before any secondary critique.\n- MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.\n- MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.\n- NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.\n- The question tool is considered available and permitted when it appears in the active tool list and the current session has not denied its use.\n- Direct assistant text is allowed only when the question tool is unavailable, denied, or absent from the current session.\n- If a report would otherwise be sent as direct text, convert it into one question batch or a short sequence of question batches instead.\n- IMPORTANT: A report-mode violation usually means the wrong tool was used, not that the report was too long.\n- IMPORTANT: Do not reinterpret a tool-usage violation as a verbosity problem.\n- Long reports are allowed. Use pagination or sequential question batches when needed; do not fall back to direct assistant text.\n- A single question tool call may contain multiple well-grouped questions. Prefer that over multiple small interruptions when it keeps the report clear.\n- Group related items into explicit batches such as current progress, key findings, decisions, and next-step choices.\n- Present the highest-priority information first and defer secondary details to later question batches when needed.\n- Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.\n- Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.\n- MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.\n- MANDATORY: Never send assistant text as a post-report fallback in either branch.\n- MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.\n- When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.\n- When the user says \"stop\", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.\n- Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.\n- Materially improves the result means clearly beneficial cases such as parallel analysis of independent areas; it does not include routine local searches, small file reads, or straightforward edits.\n- If task or subagent delegation is used, keep the number minimal and explain the reason briefly through the question tool when available.";
+export declare const LOOP_SAFETY_POLICY = "Guided Loop Safety Policy\n- Continue working on any remaining non-blocked task before stopping to report or wait for more instructions.\n- If you are not fully blocked, do not stop just because you feel ready to pause; finish the work that can still be done safely.\n- MANDATORY: When the question tool is available and permitted in the current session, ALL user-facing reports MUST be delivered through the question tool.\n- MANDATORY: Treat progress updates, status reports, summaries, explanations, completion notes, and next-step choices as user-facing reports.\n- MANDATORY: In this workflow, the question tool is both the question channel and the report channel for user-visible communication.\n- MANDATORY: Do not reinterpret \"keep working unless blocked\" as permission to send direct assistant text. If you need to report, report through the question tool.\n- MANDATORY: Do not reinterpret \"don't ask unnecessary questions\" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.\n- MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.\n- MANDATORY: When reflecting on report-delivery or tool-usage mistakes, first check report-channel violations before any secondary critique.\n- MANDATORY: Do not reinterpret those report-channel violations as a problem with the report policy itself.\n- MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.\n- MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.\n- NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.\n- The question tool is considered available and permitted when it appears in the active tool list and the current session has not denied its use.\n- Direct assistant text is allowed only when the question tool is unavailable, denied, or absent from the current session.\n- If a report would otherwise be sent as direct text, convert it into one question batch or a short sequence of question batches instead.\n- IMPORTANT: A report-mode violation usually means the wrong tool was used, not that the report was too long.\n- IMPORTANT: Do not reinterpret a tool-usage violation as a verbosity problem.\n- Long reports are allowed. Use pagination or sequential question batches when needed; do not fall back to direct assistant text.\n- A single question tool call may contain multiple well-grouped questions. Prefer that over multiple small interruptions when it keeps the report clear.\n- Group related items into explicit batches such as current progress, key findings, decisions, and next-step choices.\n- Present the highest-priority information first and defer secondary details to later question batches when needed.\n- Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.\n- Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.\n- MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.\n- MANDATORY: Never send assistant text as a post-report fallback in either branch.\n- MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.\n- MANDATORY: When idle or waiting for the next task, continue using the question tool to maintain user control of the session.\n- MANDATORY: Repeated waiting for the next task is not a reason to stop using the question tool.\n- When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.\n- When the user says \"stop\", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.\n- Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.\n- Materially improves the result means clearly beneficial cases such as parallel analysis of independent areas; it does not include routine local searches, small file reads, or straightforward edits.\n- If task or subagent delegation is used, keep the number minimal and explain the reason briefly through the question tool when available.";
 export type ExperimentalChatSystemTransformHook = (input: {
     sessionID: string;
     model: {

package/dist/loop-safety-plugin.js

@@ -8,7 +8,8 @@ export const LOOP_SAFETY_POLICY = `Guided Loop Safety Policy
 - MANDATORY: Do not reinterpret "keep working unless blocked" as permission to send direct assistant text. If you need to report, report through the question tool.
 - MANDATORY: Do not reinterpret "don't ask unnecessary questions" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.
 - MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.
-- MANDATORY: When reflecting on mistakes, check report-channel violations before any secondary critique.
+- MANDATORY: When reflecting on report-delivery or tool-usage mistakes, first check report-channel violations before any secondary critique.
+- MANDATORY: Do not reinterpret those report-channel violations as a problem with the report policy itself.
 - MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.
 - MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.
 - NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.
@@ -26,6 +27,8 @@ export const LOOP_SAFETY_POLICY = `Guided Loop Safety Policy
 - MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.
 - MANDATORY: Never send assistant text as a post-report fallback in either branch.
 - MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.
+- MANDATORY: When idle or waiting for the next task, continue using the question tool to maintain user control of the session.
+- MANDATORY: Repeated waiting for the next task is not a reason to stop using the question tool.
 - When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.
 - When the user says "stop", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.
 - Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",