opencode-copilot-account-switcher 0.2.6 → 0.2.8

package/dist/copilot-network-retry.js

@@ -13,6 +13,8 @@ const RETRYABLE_MESSAGES = [
     "unable to verify the first certificate",
     "self-signed certificate in certificate chain",
 ];
+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";
     return `${tmp}/opencode-copilot-retry-debug.log`;
@@ -47,11 +49,42 @@ function isInputIdTooLongErrorBody(payload) {
         return false;
     const error = payload.error;
     const message = String(error?.message ?? "").toLowerCase();
-    return message.includes("invalid 'input[") && message.includes(".id'") && message.includes("string too long");
+    return message.includes("string too long") && (message.includes("input id") || message.includes(".id'"));
 }
 function isInputIdTooLongMessage(text) {
     const message = text.toLowerCase();
-    return message.includes("invalid 'input[") && message.includes(".id'") && message.includes("string too long");
+    return message.includes("string too long") && (message.includes("input id") || message.includes(".id'"));
+}
+function parseInputIdTooLongDetails(text) {
+    const matched = isInputIdTooLongMessage(text);
+    if (!matched)
+        return { matched };
+    const index = text.match(/input\[(\d+)\]\.id/i);
+    const length = text.match(/got a string with length\s+(\d+)/i) ?? text.match(/length\s+(\d+)/i);
+    return {
+        matched,
+        serverReportedIndex: index ? Number(index[1]) : undefined,
+        reportedLength: length ? Number(length[1]) : undefined,
+    };
+}
+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))
+        return [];
+    return input.flatMap((item, payloadIndex) => {
+        const id = item?.id;
+        if (typeof id !== "string" || id.length <= 64)
+            return [];
+        const content = item?.content;
+        const itemKind = Array.isArray(content) && typeof content[0]?.type === "string" ? String(content[0].type) : "unknown";
+        return [{ payloadIndex, idLength: id.length, itemKind, idPreview: buildIdPreview(id) }];
+    });
 }
 function hasLongInputIds(payload) {
     const input = payload.input;
@@ -59,22 +92,62 @@ function hasLongInputIds(payload) {
         return false;
     return input.some((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
 }
-function stripLongInputIds(payload) {
+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 [];
+    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) => item.idLength === reportedLength)
+        : matches;
+    if (lengthMatches.length === 1)
+        return lengthMatches[0].item;
+    if (matches.length === 1)
+        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, serverReportedIndex, reportedLength) {
+    const input = payload.input;
+    if (!Array.isArray(input))
+        return payload;
+    const target = getTargetedLongInputId(payload, serverReportedIndex, reportedLength);
+    if (!target)
         return payload;
     let changed = false;
     const nextInput = input.map((item) => {
-        if (!item || typeof item !== "object")
+        if (item !== target)
             return item;
-        const id = item.id;
-        if (typeof id === "string" && id.length > 64) {
-            changed = true;
-            const clone = { ...item };
-            delete clone.id;
-            return clone;
-        }
-        return item;
+        changed = true;
+        const clone = { ...item };
+        delete clone.id;
+        return clone;
     });
     if (!changed)
         return payload;
@@ -98,6 +171,7 @@ function parseJsonBody(init) {
 }
 function buildRetryInit(init, payload) {
     const headers = new Headers(init?.headers);
+    headers.delete(INTERNAL_SESSION_HEADER);
     if (!headers.has("content-type")) {
         headers.set("content-type", "application/json");
     }
@@ -107,13 +181,149 @@ function buildRetryInit(init, payload) {
         body: JSON.stringify(payload),
     };
 }
-async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
-    if (response.status !== 400)
-        return response;
+function stripInternalSessionHeaderFromRequest(request) {
+    if (!(request instanceof Request))
+        return request;
+    if (!request.headers.has(INTERNAL_SESSION_HEADER))
+        return request;
+    const headers = new Headers(request.headers);
+    headers.delete(INTERNAL_SESSION_HEADER);
+    return new Request(request, { headers });
+}
+function getHeader(request, init, name) {
+    const initHeaders = new Headers(init?.headers);
+    const initValue = initHeaders.get(name);
+    if (initValue)
+        return initValue;
+    if (request instanceof Request)
+        return request.headers.get(name) ?? undefined;
+    return undefined;
+}
+function getTargetedInputId(payload, serverReportedIndex, reportedLength) {
+    const target = getTargetedLongInputId(payload, serverReportedIndex, reportedLength);
+    const id = target?.id;
+    if (typeof id !== "string")
+        return undefined;
+    return id;
+}
+function stripOpenAIItemId(part) {
+    const metadata = part.metadata;
+    if (!metadata || typeof metadata !== "object")
+        return part;
+    const openai = metadata.openai;
+    if (!openai || typeof openai !== "object")
+        return part;
+    if (!Object.hasOwn(openai, "itemId"))
+        return part;
+    const nextOpenai = { ...openai };
+    delete nextOpenai.itemId;
+    return {
+        ...part,
+        metadata: {
+            ...metadata,
+            openai: nextOpenai,
+        },
+    };
+}
+async function repairSessionPart(sessionID, failingId, ctx) {
+    const messages = await ctx?.client?.session?.messages?.({
+        path: { id: sessionID },
+    });
+    const matches = (messages?.data ?? []).flatMap((message) => {
+        if (message.info?.role !== "assistant")
+            return [];
+        return (message.parts ?? []).flatMap((part) => {
+            const itemId = part.metadata?.openai?.itemId;
+            if (itemId !== failingId || typeof message.info?.id !== "string" || typeof part.id !== "string")
+                return [];
+            return [{ messageID: message.info.id, partID: part.id, partType: String(part.type ?? "unknown") }];
+        });
+    });
+    debugLog("input-id retry session candidates", {
+        sessionID,
+        count: matches.length,
+        candidates: matches,
+    });
+    if (matches.length !== 1)
+        return false;
+    const match = matches[0];
+    debugLog("input-id retry session match", match);
+    const latest = await ctx?.client?.session?.message?.({
+        path: {
+            id: sessionID,
+            messageID: match.messageID,
+        },
+    });
+    const part = latest?.data?.parts?.find((item) => item.id === match.partID);
+    if (!part)
+        return false;
+    const body = stripOpenAIItemId(part);
+    const url = new URL(`/session/${sessionID}/message/${match.messageID}/part/${match.partID}`, ctx?.serverUrl);
+    if (ctx?.directory)
+        url.searchParams.set("directory", ctx.directory);
+    const init = {
+        method: "PATCH",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    };
+    if (ctx?.patchPart) {
+        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,
+        });
+        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;
+    }
+}
+async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx, sessionID) {
+    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;
+        return { response, retried: false, nextInit: init, retryState: undefined };
     }
     debugLog("input-id retry candidate", {
         status: response.status,
@@ -125,13 +335,16 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
         .catch(() => "");
     if (!responseText) {
         debugLog("skip input-id retry: empty response body");
-        return response;
+        return { response, retried: false, nextInit: init, retryState: undefined };
     }
-    let matched = isInputIdTooLongMessage(responseText);
+    let parsed = parseInputIdTooLongDetails(responseText);
+    let matched = parsed.matched;
     if (!matched) {
         try {
             const bodyPayload = JSON.parse(responseText);
-            matched = isInputIdTooLongErrorBody(bodyPayload);
+            const error = bodyPayload.error;
+            parsed = parseInputIdTooLongDetails(String(error?.message ?? ""));
+            matched = parsed.matched || isInputIdTooLongErrorBody(bodyPayload);
         }
         catch {
             matched = false;
@@ -139,25 +352,73 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
     }
     debugLog("input-id retry detection", {
         matched,
+        serverReportedIndex: parsed.serverReportedIndex,
+        reportedLength: parsed.reportedLength,
         bodyPreview: responseText.slice(0, 200),
     });
-    if (!matched)
-        return response;
-    const sanitized = stripLongInputIds(requestPayload);
+    debugLog("input-id retry parsed", {
+        serverReportedIndex: parsed.serverReportedIndex,
+        reportedLength: parsed.reportedLength,
+    });
+    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, retryState: undefined };
+    }
+    const payloadCandidates = getPayloadCandidates(requestPayload);
+    debugLog("input-id retry payload candidates", {
+        serverReportedIndex: parsed.serverReportedIndex,
+        candidates: payloadCandidates,
+    });
+    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", {
+            targetedPayloadIndex: targetedPayload.payloadIndex,
+            itemKind: targetedPayload.itemKind,
+            idLength: targetedPayload.idLength,
+            idPreview: targetedPayload.idPreview,
+        });
+    }
+    if (sessionID && failingId) {
+        await repairSessionPart(sessionID, failingId, ctx).catch(() => false);
+    }
+    const sanitized = stripTargetedLongInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     if (sanitized === requestPayload) {
         debugLog("skip input-id retry: sanitize made no changes");
-        return response;
+        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,
         hadPreviousResponseId: typeof requestPayload.previous_response_id === "string",
     });
-    const retried = await baseFetch(request, buildRetryInit(init, sanitized));
+    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 retried;
+    return { response: retried, retried: true, nextInit, retryState };
 }
 function toRetryableSystemError(error) {
     const base = error instanceof Error ? error : new Error(String(error));
@@ -179,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;
@@ -229,19 +521,71 @@ export function isRetryableCopilotFetchError(error) {
 export function createCopilotRetryingFetch(baseFetch, options) {
     void options;
     return async function retryingFetch(request, init) {
+        const sessionID = getHeader(request, init, INTERNAL_SESSION_HEADER);
+        const safeRequest = stripInternalSessionHeaderFromRequest(request);
+        const initHeaders = new Headers(init?.headers);
+        initHeaders.delete(INTERNAL_SESSION_HEADER);
+        const effectiveInit = init
+            ? {
+                ...init,
+                headers: initHeaders,
+            }
+            : undefined;
         debugLog("fetch start", {
-            url: request instanceof Request ? request.url : request instanceof URL ? request.href : String(request),
-            isCopilot: isCopilotUrl(request),
+            url: safeRequest instanceof Request ? safeRequest.url : safeRequest instanceof URL ? safeRequest.href : String(safeRequest),
+            isCopilot: isCopilotUrl(safeRequest),
         });
         try {
-            const response = await baseFetch(request, init);
+            const response = await baseFetch(safeRequest, effectiveInit);
             debugLog("fetch resolved", {
                 status: response.status,
                 contentType: response.headers.get("content-type") ?? undefined,
             });
-            if (isCopilotUrl(request)) {
-                const retried = await maybeRetryInputIdTooLong(request, init, response, baseFetch);
-                return withStreamDebugLogs(retried, request);
+            if (isCopilotUrl(safeRequest)) {
+                let currentResponse = response;
+                let currentInit = effectiveInit;
+                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);
             }
             return response;
         }
@@ -250,7 +594,7 @@ export function createCopilotRetryingFetch(baseFetch, options) {
                 message: getErrorMessage(error),
                 retryableByMessage: isRetryableCopilotFetchError(error),
             });
-            if (!isCopilotUrl(request) || !isRetryableCopilotFetchError(error)) {
+            if (!isCopilotUrl(safeRequest) || !isRetryableCopilotFetchError(error)) {
                 throw error;
             }
             throw toRetryableSystemError(error);

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- 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.
@@ -23,6 +24,11 @@ export const LOOP_SAFETY_POLICY = `Guided Loop Safety Policy
 - Present the highest-priority information first and defer secondary details to later question batches when needed.
 - Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.
 - Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.
+- 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/dist/plugin-hooks.d.ts

@@ -1,7 +1,27 @@
 import { type CopilotPluginHooks } from "./loop-safety-plugin.js";
-import { createCopilotRetryingFetch } from "./copilot-network-retry.js";
+import { type CopilotRetryContext, type FetchLike } from "./copilot-network-retry.js";
 import { type StoreFile } from "./store.js";
 import { type CopilotAuthState, type CopilotProviderConfig, type OfficialCopilotConfig } from "./upstream/copilot-loader-adapter.js";
+type ChatHeadersHook = (input: {
+    sessionID: string;
+    agent: string;
+    model: {
+        providerID: string;
+    };
+    provider: {
+        source: string;
+        info: object;
+        options: object;
+    };
+    message: {
+        id: string;
+    };
+}, output: {
+    headers: Record<string, string>;
+}) => Promise<void>;
+type CopilotPluginHooksWithChatHeaders = CopilotPluginHooks & {
+    "chat.headers"?: ChatHeadersHook;
+};
 export declare function buildPluginHooks(input: {
     auth: NonNullable<CopilotPluginHooks["auth"]>;
     loadStore?: () => Promise<StoreFile | undefined>;
@@ -9,5 +29,9 @@ export declare function buildPluginHooks(input: {
         getAuth: () => Promise<CopilotAuthState | undefined>;
         provider?: CopilotProviderConfig;
     }) => Promise<OfficialCopilotConfig | undefined>;
-    createRetryFetch?: typeof createCopilotRetryingFetch;
-}): CopilotPluginHooks;
+    createRetryFetch?: (fetch: FetchLike, ctx?: CopilotRetryContext) => FetchLike;
+    client?: CopilotRetryContext["client"];
+    directory?: CopilotRetryContext["directory"];
+    serverUrl?: CopilotRetryContext["serverUrl"];
+}): CopilotPluginHooksWithChatHeaders;
+export {};

package/dist/plugin-hooks.js

@@ -1,5 +1,5 @@
-import { createLoopSafetySystemTransform } from "./loop-safety-plugin.js";
-import { createCopilotRetryingFetch } from "./copilot-network-retry.js";
+import { createLoopSafetySystemTransform, isCopilotProvider, } from "./loop-safety-plugin.js";
+import { createCopilotRetryingFetch, } from "./copilot-network-retry.js";
 import { readStoreSafe } from "./store.js";
 import { loadOfficialCopilotConfig, } from "./upstream/copilot-loader-adapter.js";
 export function buildPluginHooks(input) {
@@ -19,15 +19,25 @@ export function buildPluginHooks(input) {
         }
         return {
             ...config,
-            fetch: createRetryFetch(config.fetch),
+            fetch: createRetryFetch(config.fetch, {
+                client: input.client,
+                directory: input.directory,
+                serverUrl: input.serverUrl,
+            }),
         };
     };
+    const chatHeaders = async (hookInput, output) => {
+        if (!isCopilotProvider(hookInput.model.providerID))
+            return;
+        output.headers["x-opencode-session-id"] = hookInput.sessionID;
+    };
     return {
         auth: {
             ...input.auth,
             provider: input.auth.provider ?? "github-copilot",
             loader,
         },
+        "chat.headers": chatHeaders,
         "experimental.chat.system.transform": createLoopSafetySystemTransform(loadStore),
     };
 }

package/dist/plugin.js

@@ -443,7 +443,10 @@ async function switchAccount(client, entry) {
         body: payload,
     });
 }
-export const CopilotAccountSwitcher = async ({ client }) => {
+export const CopilotAccountSwitcher = async (input) => {
+    const client = input.client;
+    const directory = input.directory;
+    const serverUrl = input.serverUrl;
     const methods = [
         {
             type: "oauth",
@@ -700,6 +703,7 @@ export const CopilotAccountSwitcher = async ({ client }) => {
                 store.active = name;
                 store.accounts[name].lastUsed = now();
                 await writeStore(store);
+                console.log("Switched account. If a later Copilot session hits input[*].id too long after switching, enable Copilot Network Retry from the menu.");
                 continue;
             }
         }
@@ -709,5 +713,8 @@ export const CopilotAccountSwitcher = async ({ client }) => {
             provider: "github-copilot",
             methods,
         },
+        client,
+        directory,
+        serverUrl,
     });
 };