cursor-opencode-provider 0.8.1 → 0.8.3

package/dist/auth-renewal.js

@@ -4,6 +4,7 @@ import { AuthExchangeError, decodeJwtPayload, exchangeApiKey, isExchangeableApiK
 // OpenCode's SessionRetry keys off such words in provider error messages.
 import { CursorAuthError, CursorServerError, sanitizeHostTerminalMessage } from "./errors.js";
 import { errorMessage, trace } from "./debug.js";
+import { processShared } from "./process-shared.js";
 // Credential renewal policy. The two Cursor credential kinds are renewed by
 // independent paths and never stand in for each other:
 //
@@ -76,6 +77,12 @@ function isoTime(ms) {
 function backoffMs(failures) {
     return Math.min(BACKOFF_MAX_MS, BACKOFF_INITIAL_MS * 2 ** Math.max(0, failures - 1));
 }
+function terminalError(failure) {
+    return new CursorAuthError(failure.message, {
+        code: failure.code,
+        ...(failure.statusCode !== undefined ? { statusCode: failure.statusCode } : {}),
+    });
+}
 function stateFor(map, key) {
     let state = map.get(key);
     if (!state) {
@@ -94,27 +101,34 @@ function recordSuccess(state) {
     state.retryAt = undefined;
     state.lastFailure = undefined;
 }
-const sessionStates = new Map();
-/** Stored refresh token → newer session token this process obtained for it. */
-const sessionSuccessors = new Map();
+// Per credential, not per module copy: every location OpenCode 2 serves loads
+// its own copy, and each would otherwise renew the same login separately.
+const sessionStates = processShared("auth-renewal.session-states.v1", () => new Map());
+/** API base + stored refresh token → newer session token obtained there. */
+const sessionSuccessors = processShared("auth-renewal.session-successors.v2", () => new Map());
 /**
  * Follow renewals this process already made, so a caller still holding an
  * older stored credential (persisting failed, or a host that persists only
  * later) gets the newest token instead of renewing again.
  */
-export function latestSessionTokens(tokens) {
+export function latestSessionTokens(tokens, baseUrl = API_BASE) {
     let current = tokens;
     for (let hops = 0; hops < MAX_SESSION_SUCCESSORS; hops++) {
-        const next = sessionSuccessors.get(current.refreshToken);
+        const next = sessionSuccessors.get(`${baseUrl}\0${current.refreshToken}`);
         if (!next || next === current.refreshToken)
             break;
         current = { accessToken: next, refreshToken: next };
     }
+    // A verified successor replaces the token it renewed even when issued in
+    // the same expiry second. A separately stored newer access token still wins.
+    if (tokens.accessToken === tokens.refreshToken)
+        return current;
     return longerLived(tokens.accessToken, current.accessToken) === current.accessToken ? current : tokens;
 }
-function rememberSuccessor(refreshToken, accessToken) {
-    sessionSuccessors.delete(refreshToken);
-    sessionSuccessors.set(refreshToken, accessToken);
+function rememberSuccessor(baseUrl, refreshToken, accessToken) {
+    const key = `${baseUrl}\0${refreshToken}`;
+    sessionSuccessors.delete(key);
+    sessionSuccessors.set(key, accessToken);
     while (sessionSuccessors.size > MAX_SESSION_SUCCESSORS) {
         const oldest = sessionSuccessors.keys().next().value;
         if (oldest === undefined)
@@ -134,22 +148,24 @@ export function isSessionRenewalDue(token, now = Date.now()) {
  */
 export async function renewSessionIfDue(tokens, options = {}) {
     const baseUrl = options.baseUrl ?? API_BASE;
-    const base = latestSessionTokens(tokens);
+    const base = latestSessionTokens(tokens, baseUrl);
     const fromMemory = base.accessToken !== tokens.accessToken;
-    if (!options.force && !isSessionRenewalDue(base.accessToken)) {
+    const state = stateFor(sessionStates, `${baseUrl}\0${base.refreshToken}`);
+    if (state.terminal)
+        throw terminalError(state.terminal);
+    if (!options.force && !isSessionRenewalDue(base.accessToken) && !state.inflight) {
         return { accessToken: base.accessToken, renewed: fromMemory };
     }
-    const state = stateFor(sessionStates, `${baseUrl}\0${base.refreshToken}`);
-    if (!state.terminal && (options.force || state.retryAt === undefined || Date.now() >= state.retryAt)) {
+    if (state.inflight || options.force || state.retryAt === undefined || Date.now() >= state.retryAt) {
         state.inflight ??= (async () => {
             const result = await refreshCursorSession(base.refreshToken, baseUrl);
             if (result.ok) {
                 const { expiresAtMs } = tokenTimes(result.accessToken);
-                if (expiresAtMs === undefined) {
-                    recordTransientFailure(state, "session refresh returned a token without expiry");
+                if (expiresAtMs === undefined || !isUsable(result.accessToken, Date.now())) {
+                    recordTransientFailure(state, "session refresh returned an unusable token");
                 }
                 else {
-                    rememberSuccessor(base.refreshToken, result.accessToken);
+                    rememberSuccessor(baseUrl, base.refreshToken, result.accessToken);
                     recordSuccess(state);
                     trace(`auth: session renewed exp=${isoTime(expiresAtMs)}`);
                     return;
@@ -159,9 +175,13 @@ export async function renewSessionIfDue(tokens, options = {}) {
                 recordTransientFailure(state, result.message);
             }
             else {
-                state.terminal = new CursorAuthError(result.kind === "policy"
-                    ? `Cursor sign-in policy blocks this login (sign_in_policy_violation); ${SIGN_IN_AGAIN} with an allowed account`
-                    : `Cursor ended this login session; ${SIGN_IN_AGAIN}`, { code: result.kind === "policy" ? "sign_in_policy_violation" : "session_logout", statusCode: result.status });
+                state.terminal = {
+                    message: result.kind === "policy"
+                        ? `Cursor sign-in policy blocks this login (sign_in_policy_violation); ${SIGN_IN_AGAIN} with an allowed account`
+                        : `Cursor ended this login session; ${SIGN_IN_AGAIN}`,
+                    code: result.kind === "policy" ? "sign_in_policy_violation" : "session_logout",
+                    ...(result.status !== undefined ? { statusCode: result.status } : {}),
+                };
                 trace(`auth: session renewal final failure kind=${result.kind}`);
                 return;
             }
@@ -172,12 +192,12 @@ export async function renewSessionIfDue(tokens, options = {}) {
         });
         await state.inflight;
     }
-    const renewed = latestSessionTokens(base);
+    const renewed = latestSessionTokens(base, baseUrl);
     if (renewed.accessToken !== base.accessToken) {
         return { accessToken: renewed.accessToken, renewed: true };
     }
     if (state.terminal)
-        throw state.terminal;
+        throw terminalError(state.terminal);
     if (!isUsable(base.accessToken, Date.now())) {
         throw new CursorAuthError(`Cursor login expired and could not be renewed (${sanitizeHostTerminalMessage(state.lastFailure ?? "no renewal attempt allowed yet")}); ${SIGN_IN_AGAIN}`, { code: "session_expired" });
     }
@@ -188,7 +208,7 @@ export async function renewSessionIfDue(tokens, options = {}) {
     };
 }
 // ── API key ──
-const apiKeyStates = new Map();
+const apiKeyStates = processShared("auth-renewal.api-key-states.v1", () => new Map());
 /**
  * JWT for a raw `crsr_` API key: the cached or `seed` JWT while it is not
  * within five minutes of expiry, otherwise a fresh exchange. Cached per API
@@ -213,7 +233,15 @@ export async function resolveApiKeyToken(apiKey, options = {}) {
         state.inflight ??= (async () => {
             try {
                 const pair = await exchangeApiKey(apiKey, baseUrl);
-                state.token = state.token ? longerLived(state.token, pair.accessToken) : pair.accessToken;
+                if (isExchangeableApiKey(pair.accessToken) || tokenTimes(pair.accessToken).expiresAtMs === undefined ||
+                    !isUsable(pair.accessToken, Date.now())) {
+                    throw new AuthExchangeError("API key exchange returned an unusable token");
+                }
+                // A forced exchange follows a server rejection: keeping the rejected
+                // JWT on an expiry tie would retry the request with that same token.
+                state.token = options.force || !state.token
+                    ? pair.accessToken
+                    : longerLived(state.token, pair.accessToken);
                 recordSuccess(state);
                 trace(`auth: API key exchanged exp=${isoTime(tokenTimes(pair.accessToken).expiresAtMs)}`);
             }
@@ -225,9 +253,13 @@ export async function resolveApiKeyToken(apiKey, options = {}) {
                 }
                 else {
                     const status = error instanceof AuthExchangeError ? error.status : undefined;
-                    state.terminal = new CursorAuthError(kind === "policy"
-                        ? "Cursor sign-in policy blocks this API key (sign_in_policy_violation); use an allowed account"
-                        : `Cursor rejected the API key${status ? ` (HTTP ${status})` : ""}; create a new key and sign in with it`, { code: kind === "policy" ? "sign_in_policy_violation" : "api_key_rejected", ...(status ? { statusCode: status } : {}) });
+                    state.terminal = {
+                        message: kind === "policy"
+                            ? "Cursor sign-in policy blocks this API key (sign_in_policy_violation); use an allowed account"
+                            : `Cursor rejected the API key${status ? ` (HTTP ${status})` : ""}; create a new key and sign in with it`,
+                        code: kind === "policy" ? "sign_in_policy_violation" : "api_key_rejected",
+                        ...(status ? { statusCode: status } : {}),
+                    };
                     trace(`auth: API key exchange final failure kind=${kind} status=${status ?? "none"}`);
                 }
             }
@@ -240,7 +272,7 @@ export async function resolveApiKeyToken(apiKey, options = {}) {
     if (state.token && isUsable(state.token, Date.now()))
         return result(state.token);
     if (state.terminal)
-        throw state.terminal;
+        throw terminalError(state.terminal);
     throw new CursorServerError(`Cursor API key exchange failed (${sanitizeHostTerminalMessage(state.lastFailure ?? "waiting before the next attempt")}); it is retried automatically`, { transient: true, replaySafe: true });
 }
 /**

package/dist/billing.d.ts

@@ -0,0 +1,105 @@
+/**
+ * What OpenCode is told a Cursor turn costs at catalog rates.
+ *
+ * OpenCode prices every step finish and adds it to the session: OpenCode 1.x
+ * from `providerMetadata.copilot.totalNanoAiu` when present
+ * (`session/session.ts` getUsage), OpenCode 2 always from the step's tokens at
+ * the model's catalog rates. Each step's token total must also stay equal to
+ * Cursor's context occupancy, because both hosts show context use and decide
+ * compaction from the latest step's tokens. Cursor reports token counters only
+ * once, in `TurnEnded`, aggregated over every model call of its Run.
+ *
+ * So each tool step is billed an estimate shaped like one model call (the
+ * context carried over from the previous step read from cache, the rest new
+ * input), and the turn's last step settles the difference to its catalog-priced
+ * cost: its input/cache split is chosen so the token-priced cost approaches the
+ * outstanding amount, and the same amount goes into `totalNanoAiu`. Both hosts
+ * then bill identical amounts at the unmodified catalog rates. What a final
+ * step cannot carry stays outstanding for a later priced turn-end. Settlement
+ * is bounded by minimum and maximum token prices and whole-token rounding;
+ * negative balances cannot refund prior host charges.
+ */
+import type { LanguageModelV3Usage } from "@ai-sdk/provider";
+import { type OpenCodeModelCost } from "./pricing.js";
+import { type CursorUsageCounters } from "./usage.js";
+/** USD per token for each category a host prices. */
+export type StepPrices = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+};
+/**
+ * Price entry the catalog gave this model: `<wire>-fast` for a Fast variant
+ * with its own published rate, else the wire id (a long-context entry is
+ * priced from the base entry and its over-200k tier), as `model-config.ts` does.
+ */
+export declare function cursorPricingId(wireModelId: string, parameterValues: ReadonlyArray<{
+    id: string;
+    value: string;
+}>): string;
+/** The rates a host applies to a step with `inputSideTokens` of prompt (its context tier). */
+export declare function hostStepPrices(cost: OpenCodeModelCost | undefined, inputSideTokens: number): StepPrices | undefined;
+/** What a host charges for `usage` at `prices`. */
+export declare function hostUsageCostUsd(prices: StepPrices, usage: LanguageModelV3Usage): number;
+/**
+ * Catalog-priced Run cost from aggregate `TurnEnded` counters. The final
+ * context approximates the prompt tier, bounded by total input so output alone
+ * cannot select a higher tier. Per-call tiers are unavailable: a Run crossing
+ * tiers or compacting internally cannot be priced exactly from these totals.
+ * A cache category without its own published rate is priced as input.
+ */
+export declare function turnEndedCostUsd(cost: OpenCodeModelCost | undefined, counters: CursorUsageCounters, contextTokens: number): number | undefined;
+/**
+ * Occupancy-shaped usage for one step: `usedTokens` in total (`output = 1`, so
+ * hosts accept it as the context snapshot), `prefixTokens` of it read from
+ * cache and the rest new input. With `targetUsd`, the split moves between
+ * input and cache read (and cache write only when those two cannot reach it)
+ * so the host-priced cost meets the target as closely as the total allows.
+ */
+export declare function shapeStepUsage(input: {
+    usedTokens: number;
+    prefixTokens: number;
+    prices: StepPrices | undefined;
+    targetUsd?: number;
+}): {
+    usage: LanguageModelV3Usage;
+    costUsd: number;
+};
+/** `providerMetadata.copilot.totalNanoAiu` for a step that costs `usd`. */
+export declare function nanoAiuForUsd(usd: number): number;
+/** Estimates belong to one Run and are replaced only by that Run's counters. */
+export type RunCostEstimate = {
+    estimatedUsd?: number;
+    ledgerEpoch?: object;
+};
+type LedgerTotals = {
+    realUsd: number;
+    billedUsd: number;
+};
+type LedgerEntry = LedgerTotals & {
+    estimatedUsd: number;
+};
+/**
+ * Per OpenCode session: catalog-priced cost (from `TurnEnded`) and what
+ * this provider has reported to the host. Priced turn-ends reconcile the balance.
+ */
+export declare class BillingLedger {
+    private readonly entries;
+    constructor(entries?: Map<string, LedgerEntry>);
+    private entry;
+    recordReal(key: string, usd: number, run?: RunCostEstimate): void;
+    recordBilled(key: string, usd: number, run?: RunCostEstimate): void;
+    /** Confirmed plus unconfirmed cost minus the amount reported to the host. */
+    outstanding(key: string): number;
+    estimated(key: string): number;
+    totals(key: string): LedgerTotals;
+    clear(): void;
+}
+export declare const billingLedger: BillingLedger;
+/** The catalog cost entry for this Run's model, if Cursor publishes one. */
+export declare function cursorRunCost(wireModelId: string, parameterValues: ReadonlyArray<{
+    id: string;
+    value: string;
+}>): OpenCodeModelCost | undefined;
+export {};

package/dist/billing.js

@@ -0,0 +1,212 @@
+import { getCursorModelCost, hasCursorFastPricing } from "./pricing.js";
+import { buildLanguageModelV3UsageFromCounters } from "./usage.js";
+const PER_MILLION = 1_000_000;
+const CONTEXT_TIER_TOKENS = 200_000;
+/** OpenCode 1.x divides `totalNanoAiu` by 1e11 to get USD. */
+const NANO_AIU_PER_USD = 100_000_000_000;
+/**
+ * Price entry the catalog gave this model: `<wire>-fast` for a Fast variant
+ * with its own published rate, else the wire id (a long-context entry is
+ * priced from the base entry and its over-200k tier), as `model-config.ts` does.
+ */
+export function cursorPricingId(wireModelId, parameterValues) {
+    const fast = parameterValues.some((parameter) => parameter.id === "fast" && parameter.value === "true");
+    return fast && hasCursorFastPricing(wireModelId) ? `${wireModelId}-fast` : wireModelId;
+}
+/** The rates a host applies to a step with `inputSideTokens` of prompt (its context tier). */
+export function hostStepPrices(cost, inputSideTokens) {
+    if (!cost)
+        return undefined;
+    const tier = cost.context_over_200k && inputSideTokens > CONTEXT_TIER_TOKENS ? cost.context_over_200k : cost;
+    return {
+        input: tier.input / PER_MILLION,
+        output: tier.output / PER_MILLION,
+        // Both hosts charge an unpriced cache category nothing.
+        cacheRead: (tier.cache_read ?? 0) / PER_MILLION,
+        cacheWrite: (tier.cache_write ?? 0) / PER_MILLION,
+    };
+}
+/** What a host charges for `usage` at `prices`. */
+export function hostUsageCostUsd(prices, usage) {
+    const input = usage.inputTokens;
+    return (input.noCache ?? 0) * prices.input
+        + (input.cacheRead ?? 0) * prices.cacheRead
+        + (input.cacheWrite ?? 0) * prices.cacheWrite
+        + (usage.outputTokens.total ?? 0) * prices.output;
+}
+/**
+ * Catalog-priced Run cost from aggregate `TurnEnded` counters. The final
+ * context approximates the prompt tier, bounded by total input so output alone
+ * cannot select a higher tier. Per-call tiers are unavailable: a Run crossing
+ * tiers or compacting internally cannot be priced exactly from these totals.
+ * A cache category without its own published rate is priced as input.
+ */
+export function turnEndedCostUsd(cost, counters, contextTokens) {
+    if (!cost)
+        return undefined;
+    // Reuse the canonical partition guard; inconsistent cache counters must not
+    // create billable input beyond input_tokens. Keep the raw fields diagnostic.
+    const usage = buildLanguageModelV3UsageFromCounters(counters);
+    const input = usage.inputTokens;
+    const promptTokens = Math.min(input.total ?? 0, Math.max(0, contextTokens));
+    const tier = cost.context_over_200k && promptTokens > CONTEXT_TIER_TOKENS ? cost.context_over_200k : cost;
+    return ((input.noCache ?? 0) * tier.input
+        + (input.cacheRead ?? 0) * (tier.cache_read ?? tier.input)
+        + (input.cacheWrite ?? 0) * (tier.cache_write ?? tier.input)
+        + (usage.outputTokens.total ?? 0) * tier.output) / PER_MILLION;
+}
+function usageOf(split) {
+    return {
+        inputTokens: {
+            total: split.noCache + split.cacheRead + split.cacheWrite,
+            noCache: split.noCache,
+            cacheRead: split.cacheRead,
+            cacheWrite: split.cacheWrite,
+        },
+        outputTokens: { total: 1, text: 1, reasoning: 0 },
+    };
+}
+/**
+ * Split `inputTokens` between two categories so their cost is as close to
+ * `budget` as whole tokens allow, clamped to what the pair can carry.
+ */
+function mix(inputTokens, budget, low, high) {
+    const split = { noCache: 0, cacheRead: 0, cacheWrite: 0 };
+    const span = high.price - low.price;
+    const atHigh = span > 0
+        ? Math.min(inputTokens, Math.max(0, Math.round((budget - inputTokens * low.price) / span)))
+        : 0;
+    split[high.category] += atHigh;
+    split[low.category] += inputTokens - atHigh;
+    return split;
+}
+/**
+ * Occupancy-shaped usage for one step: `usedTokens` in total (`output = 1`, so
+ * hosts accept it as the context snapshot), `prefixTokens` of it read from
+ * cache and the rest new input. With `targetUsd`, the split moves between
+ * input and cache read (and cache write only when those two cannot reach it)
+ * so the host-priced cost meets the target as closely as the total allows.
+ */
+export function shapeStepUsage(input) {
+    const used = Math.max(0, Math.trunc(input.usedTokens));
+    if (used <= 0) {
+        return {
+            usage: {
+                inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+                outputTokens: { total: 0, text: 0, reasoning: 0 },
+            },
+            costUsd: 0,
+        };
+    }
+    const inputTokens = used - 1;
+    const cacheRead = Math.min(inputTokens, Math.max(0, Math.trunc(input.prefixTokens)));
+    let split = { noCache: inputTokens - cacheRead, cacheRead, cacheWrite: 0 };
+    const prices = input.prices;
+    if (prices && input.targetUsd !== undefined) {
+        const budget = input.targetUsd - prices.output;
+        const options = [
+            { category: "noCache", price: prices.input },
+            { category: "cacheRead", price: prices.cacheRead },
+        ];
+        const [low, high] = [...options].sort((a, b) => a.price - b.price);
+        if (budget >= inputTokens * low.price && budget <= inputTokens * high.price) {
+            split = mix(inputTokens, budget, low, high);
+        }
+        else {
+            const write = { category: "cacheWrite", price: prices.cacheWrite };
+            const all = [...options, write].sort((a, b) => a.price - b.price);
+            const cheapest = all[0];
+            const dearest = all[all.length - 1];
+            split = budget < inputTokens * low.price
+                ? mix(inputTokens, budget, cheapest, low)
+                : mix(inputTokens, budget, high, dearest);
+        }
+    }
+    const usage = usageOf(split);
+    return { usage, costUsd: prices ? hostUsageCostUsd(prices, usage) : 0 };
+}
+/** `providerMetadata.copilot.totalNanoAiu` for a step that costs `usd`. */
+export function nanoAiuForUsd(usd) {
+    return Math.max(0, Math.round(usd * NANO_AIU_PER_USD));
+}
+const MAX_LEDGERS = 1_024;
+/**
+ * Per OpenCode session: catalog-priced cost (from `TurnEnded`) and what
+ * this provider has reported to the host. Priced turn-ends reconcile the balance.
+ */
+export class BillingLedger {
+    entries;
+    constructor(entries = new Map()) {
+        this.entries = entries;
+    }
+    entry(key) {
+        let entry = this.entries.get(key);
+        if (entry) {
+            this.entries.delete(key);
+        }
+        else {
+            entry = { realUsd: 0, billedUsd: 0, estimatedUsd: 0 };
+            while (this.entries.size >= MAX_LEDGERS) {
+                const oldest = this.entries.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                this.entries.delete(oldest);
+            }
+        }
+        this.entries.set(key, entry);
+        return entry;
+    }
+    recordReal(key, usd, run) {
+        if (!Number.isFinite(usd) || usd < 0)
+            return;
+        const entry = this.entry(key);
+        entry.realUsd += usd;
+        // Missing TurnEnded is unknown cost, not free work. Other Runs' estimates
+        // stay provisionally covered, including Runs already closed by the host.
+        const priorEstimate = run?.ledgerEpoch === entry ? run.estimatedUsd ?? 0 : 0;
+        entry.estimatedUsd = Math.max(0, entry.estimatedUsd - priorEstimate);
+        if (run)
+            run.estimatedUsd = 0;
+    }
+    recordBilled(key, usd, run) {
+        if (!Number.isFinite(usd) || usd <= 0)
+            return;
+        const entry = this.entry(key);
+        entry.billedUsd += usd;
+        if (run) {
+            // An evicted session starts a new ledger; its old Run estimate must not
+            // replace another Run's estimates in the new entry.
+            if (run.ledgerEpoch !== entry)
+                run.estimatedUsd = 0;
+            run.ledgerEpoch = entry;
+            entry.estimatedUsd += usd;
+            run.estimatedUsd = (run.estimatedUsd ?? 0) + usd;
+        }
+    }
+    /** Confirmed plus unconfirmed cost minus the amount reported to the host. */
+    outstanding(key) {
+        const entry = this.entries.get(key);
+        return entry ? entry.realUsd + entry.estimatedUsd - entry.billedUsd : 0;
+    }
+    estimated(key) {
+        return this.entries.get(key)?.estimatedUsd ?? 0;
+    }
+    totals(key) {
+        const entry = this.entries.get(key);
+        return entry ? { realUsd: entry.realUsd, billedUsd: entry.billedUsd } : { realUsd: 0, billedUsd: 0 };
+    }
+    clear() {
+        this.entries.clear();
+    }
+}
+// Plugin and SDK loaders can evaluate separate copies of this package in one
+// process. Share plain ledger data, rather than a class instance owned by one
+// module graph, so session balances survive those loader transitions.
+const BILLING_ENTRIES = Symbol.for("cursor-opencode-provider.billing-ledger.v2");
+const processState = globalThis;
+const sharedEntries = processState[BILLING_ENTRIES] ??= new Map();
+export const billingLedger = new BillingLedger(sharedEntries);
+/** The catalog cost entry for this Run's model, if Cursor publishes one. */
+export function cursorRunCost(wireModelId, parameterValues) {
+    return getCursorModelCost(cursorPricingId(wireModelId, parameterValues));
+}

package/dist/classic-tool-results.d.ts

@@ -0,0 +1 @@
+export declare function normalizeClassicInterruptedResults(messages: readonly unknown[]): any[];

package/dist/classic-tool-results.js

@@ -0,0 +1,42 @@
+import { restoreOpenCodeTimeout } from "./shell-timeout.js";
+/**
+ * OpenCode 1 exposes interrupted partial output as successful SDK output:
+ * https://github.com/anomalyco/opencode/blob/v1.18.31/packages/opencode/src/session/message-v2.ts#L325-L346
+ * Its shell also completes with exit:null after cancellation and appends its
+ * own metadata block (tool/shell.ts L542-L589). Preserve failure in the model
+ * projection while retaining progress text. A timed-out shell is stored with
+ * a display notice in place of that block and only `state.output` reaches the
+ * model, so the projection restores the block. Stored messages are not mutated.
+ */
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+export function normalizeClassicInterruptedResults(messages) {
+    return messages.map(message => {
+        const msg = record(message);
+        if (!msg || !Array.isArray(msg.parts))
+            return message;
+        return { ...msg, parts: msg.parts.map(item => {
+                const part = record(item);
+                const state = record(part?.state);
+                if (part?.type !== "tool" || typeof part.callID !== "string" || !part.callID.startsWith("cursor_") || !state)
+                    return item;
+                const metadata = record(state.metadata);
+                const timeoutMs = metadata?.cursorShellTimeoutMs;
+                if (state.status === "completed" && part.tool === "bash" && typeof state.output === "string"
+                    && typeof timeoutMs === "number" && Number.isSafeInteger(timeoutMs) && timeoutMs >= 0) {
+                    return { ...part, state: { ...state, output: restoreOpenCodeTimeout(state.output, timeoutMs) } };
+                }
+                const partialError = state.status === "error" && metadata?.interrupted === true;
+                // Null exit and the native trailing block must agree. Ordinary successful
+                // stdout can legitimately contain the same words or markup.
+                const shellAbort = state.status === "completed" && part.tool === "bash" && metadata?.exit === null
+                    && typeof state.output === "string" && /<shell_metadata>\r?\nUser aborted the command\r?\n<\/shell_metadata>\s*$/.test(state.output);
+                if (!partialError && !shellAbort)
+                    return item;
+                const message = typeof state.error === "string" && state.error ? state.error : "Tool execution interrupted";
+                const progress = shellAbort ? state.output : typeof metadata?.output === "string" ? metadata.output : "";
+                const { output: _output, title: _title, attachments: _attachments, ...base } = state;
+                return { ...part, state: { ...base, status: "error", error: progress ? `${message}\n\n${progress}` : message,
+                        metadata: { ...metadata, interrupted: false } } };
+            }) };
+    });
+}

package/dist/context/build.d.ts

@@ -55,6 +55,7 @@ export type DynamicRequestContextKey = typeof DYNAMIC_REQUEST_CONTEXT_KEYS[numbe
  * `skills.ts`); never kept on a frozen base.
  */
 export declare const HOST_DUPLICATED_REQUEST_CONTEXT_KEYS: readonly ["agent_skills", "agent_skills_info_complete"];
+export declare function resetWorkspaceFactsForTests(): void;
 /**
  * Full RequestContext payload for live UMA + exec #10 reply.
  * Workspace env/git/layout, the host system-instructions rule, and

package/dist/context/build.js

@@ -8,7 +8,7 @@ import { buildEnv } from "./env.js";
 import { ensureOpencodeProjectDir } from "./paths.js";
 import { holdCapabilityOverlay } from "./overlay.js";
 import { agentSkillsForCursor, applyAgentSkillsToContext, hostSkillFiles, loadBridgeSkills, skillToolAdvertised, } from "./skills.js";
-import { traceRequestContextPaths } from "../debug.js";
+import { trace, traceRequestContextPaths } from "../debug.js";
 /** Rule name Cursor shows for the host system context (not a file). */
 export const SYSTEM_INSTRUCTIONS_RULE_PATH = "OpenCode system instructions";
 /**
@@ -95,6 +95,34 @@ function stripHostDuplicatedRequestContextFields(context) {
         delete context[key];
     keepSystemInstructionsRule(context);
 }
+/**
+ * How long one workspace's git and layout discovery serves later builds. A new
+ * session's first message opens two Runs moments apart (OpenCode's title
+ * request and the turn itself) on separate conversations; each froze its own
+ * copy, and `git status` dominates on a large repository (1.3 s warm on 35k
+ * tracked files; both discoveries of one observed session took about 5 s).
+ * Each conversation freezes what it got anyway.
+ */
+const WORKSPACE_FACTS_REUSE_MS = 30_000;
+const workspaceFacts = new Map();
+function collectWorkspaceFacts(workspaceRoot) {
+    const now = Date.now();
+    for (const [root, entry] of workspaceFacts) {
+        if (now - entry.at >= WORKSPACE_FACTS_REUSE_MS)
+            workspaceFacts.delete(root);
+    }
+    const cached = workspaceFacts.get(workspaceRoot);
+    if (cached) {
+        trace(`workspace facts: reused ageMs=${now - cached.at}`);
+        return cached.facts;
+    }
+    const facts = Promise.all([collectGit(workspaceRoot), collectProjectLayout(workspaceRoot)]);
+    workspaceFacts.set(workspaceRoot, { at: now, facts });
+    return facts;
+}
+export function resetWorkspaceFactsForTests() {
+    workspaceFacts.clear();
+}
 /**
  * Full RequestContext payload for live UMA + exec #10 reply.
  * Workspace env/git/layout, the host system-instructions rule, and
@@ -104,10 +132,9 @@ function stripHostDuplicatedRequestContextFields(context) {
 export async function buildRequestContext(input) {
     const workspaceRoot = path.resolve(input.workspaceRoot || process.cwd());
     const config = input.mergedConfig ?? await loadMergedConfig(workspaceRoot);
-    const [dynamic, git, layout] = await Promise.all([
+    const [dynamic, [git, layout]] = await Promise.all([
         buildDynamicRequestContextFromDiscovery(input, workspaceRoot, config),
-        collectGit(workspaceRoot),
-        collectProjectLayout(workspaceRoot),
+        collectWorkspaceFacts(workspaceRoot),
     ]);
     const workspace = {
         env: buildEnv(workspaceRoot),
@@ -118,7 +145,7 @@ export async function buildRequestContext(input) {
         env_info_complete: true,
         repository_info_complete: true,
         git_repo_info_complete: true,
-        git_status_info_complete: true,
+        git_status_info_complete: git.statusComplete,
     };
     const base = withSystemInstructions(workspace, input.systemInstructions);
     const skillLocations = await resolveSkillLocations(input, workspaceRoot);