oira666_pi-limits-wait 0.5.2 → 0.5.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/ui.ts CHANGED
@@ -1,179 +1,234 @@
1
- import {
2
- DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
3
- DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS,
4
- DEFAULT_WAITING_ENV_VAR,
5
- FREEZING_ENV_VAR,
6
- MAX_RETRY_ENV_VAR,
7
- RETRY_INTERVAL_ENV_VAR,
8
- } from "./constants.js";
9
- import { state } from "./state.js";
10
- import type { RetryReason } from "./types.js";
11
-
12
- export function formatDuration(ms: number): string {
13
- const totalSecs = Math.max(0, Math.ceil(ms / 1_000));
14
- const hours = Math.floor(totalSecs / 3_600);
15
- const mins = Math.floor((totalSecs % 3_600) / 60);
16
- const secs = (totalSecs % 60).toString().padStart(2, "0");
17
- return hours > 0 ? `${hours}h ${mins}m ${secs}s` : `${mins}m ${secs}s`;
18
- }
19
-
20
- export function formatErrorDetail(errorMessage: string, maxLength = 500): string {
21
- const oneLine = errorMessage.replace(/\s+/g, " ").trim();
22
- if (!oneLine) return "unknown error";
23
- return oneLine.length > maxLength ? `${oneLine.slice(0, maxLength - 1)}…` : oneLine;
24
- }
25
-
26
- export function reasonLabel(reason: RetryReason): string {
27
- if (reason === "overloaded") return "Server overloaded";
28
- if (reason === "authentication") return "Authentication refresh pending";
29
- if (reason === "model-frozen") return "Model frozen after error";
30
- if (reason === "network") return "Network/timeout error";
31
- if (reason === "retry") return "Retrying after error";
32
- return "Rate limited";
33
- }
34
-
35
- function envBoolean(raw: string | undefined, defaultValue: boolean): boolean {
36
- if (raw === undefined) return defaultValue;
37
- const value = raw.trim().toLowerCase();
38
- return !(value === "false" || value === "0" || value === "no" || value === "off");
39
- }
40
-
41
- function envNonNegativeInteger(raw: string | undefined, defaultValue: number, maximum = Number.MAX_SAFE_INTEGER): number {
42
- if (raw === undefined || !/^\d+$/.test(raw.trim())) return defaultValue;
43
- const value = Number(raw);
44
- return Number.isSafeInteger(value) ? Math.min(value, maximum) : defaultValue;
45
- }
46
-
47
- export function freezingEnabled(): boolean {
48
- return envBoolean(process.env[FREEZING_ENV_VAR], true);
49
- }
50
-
51
- /** Load unknown-error retry settings once per extension instance/reload. */
52
- export function loadUnknownErrorRetrySettings(): void {
53
- state.unknownErrorWaitingEnabled = envBoolean(process.env[DEFAULT_WAITING_ENV_VAR], true);
54
- const maxRetries = envNonNegativeInteger(
55
- process.env[MAX_RETRY_ENV_VAR],
56
- DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
57
- Number.MAX_SAFE_INTEGER - 1,
58
- );
59
- // The first failed request is not itself a retry.
60
- state.nonRetryableMaxAttempts = maxRetries + 1;
61
-
62
- // PI_LIMITS_WAIT_RETRY_INTERVAL is expressed in seconds; internally waits use ms.
63
- const intervalSeconds = envNonNegativeInteger(
64
- process.env[RETRY_INTERVAL_ENV_VAR],
65
- DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS / 1_000,
66
- // Node timers cannot reliably wait longer than this in one timeout.
67
- Math.floor(2_147_483_647 / 1_000),
68
- );
69
- state.nonRetryableRetryDelayMs = intervalSeconds * 1_000;
70
- }
71
-
72
- function countdownText(reason: RetryReason, deadline: number, allowSkip: boolean): string {
73
- const remaining = Math.max(0, deadline - Date.now());
74
- const totalSecs = Math.ceil(remaining / 1_000);
75
- const mins = Math.floor(totalSecs / 60);
76
- const secs = (totalSecs % 60).toString().padStart(2, "0");
77
- return (
78
- `⏳ ${reasonLabel(reason)} — next retry in ${mins}m ${secs}s` +
79
- (allowSkip ? " (Enter to retry now)" : "")
80
- );
81
- }
82
-
83
- export function showAmbientRetryStatus(reason: RetryReason, waitMs: number): void {
84
- const ctx = state.sharedCtx;
85
- if (!ctx) return;
86
-
87
- state.ambientStatusCleanup?.();
88
- if (waitMs <= 0) return;
89
-
90
- const deadline = Date.now() + waitMs;
91
- const tick = () => {
92
- if (Date.now() >= deadline) {
93
- state.ambientStatusCleanup?.();
94
- return;
95
- }
96
- ctx.ui.setWorkingMessage(countdownText(reason, deadline, false));
97
- };
98
-
99
- tick();
100
- const ticker = setInterval(tick, 1_000);
101
- state.ambientStatusCleanup = () => {
102
- clearInterval(ticker);
103
- state.ambientStatusCleanup = undefined;
104
- ctx.ui.setWorkingMessage();
105
- };
106
- }
107
-
108
- export function clearAmbientRetryStatus(): void {
109
- state.ambientStatusCleanup?.();
110
- }
111
-
112
- export function clearModelStatus(): void {
113
- state.modelStatusCleanup?.();
114
- }
115
-
116
- export function waitForRetry(
117
- reason: RetryReason,
118
- waitMs: number,
119
- signal?: AbortSignal,
120
- ): Promise<"waited" | "skipped" | "aborted"> {
121
- if (waitMs <= 0) return Promise.resolve(signal?.aborted ? "aborted" : "waited");
122
-
123
- return new Promise((resolve) => {
124
- if (signal?.aborted) { resolve("aborted"); return; }
125
-
126
- const ctx = state.sharedCtx;
127
- const deadline = Date.now() + waitMs;
128
- let done = false;
129
- let unsubInput: (() => void) | undefined;
130
-
131
- try {
132
- unsubInput = ctx?.ui.onTerminalInput((data) => {
133
- if (done) return undefined;
134
- if (data === "\r" || data === "\n") {
135
- cleanup();
136
- resolve("skipped");
137
- return { consume: true };
138
- }
139
- if (data === "\x1b") {
140
- cleanup();
141
- resolve("aborted");
142
- return { consume: true };
143
- }
144
- return undefined;
145
- });
146
- } catch { /* UI unavailable */ }
147
-
148
- const onAbort = () => { if (!done) { cleanup(); resolve("aborted"); } };
149
- signal?.addEventListener("abort", onAbort);
150
-
151
- const tick = () => {
152
- ctx?.ui.setWorkingMessage(countdownText(reason, deadline, Boolean(unsubInput)));
153
- };
154
-
155
- tick();
156
- const ticker = setInterval(() => {
157
- if (Date.now() >= deadline) { cleanup(); resolve("waited"); return; }
158
- tick();
159
- }, 1_000);
160
- const timer = setTimeout(() => { if (!done) { cleanup(); resolve("waited"); } }, Math.max(0, deadline - Date.now()));
161
-
162
- function cleanup() {
163
- done = true;
164
- clearInterval(ticker);
165
- clearTimeout(timer);
166
- signal?.removeEventListener("abort", onAbort);
167
- unsubInput?.();
168
- ctx?.ui.setWorkingMessage();
169
- clearAmbientRetryStatus();
170
- }
171
- });
172
- }
173
-
174
- export function waitForRateLimit(
175
- waitMs: number,
176
- signal?: AbortSignal,
177
- ): Promise<"waited" | "skipped" | "aborted"> {
178
- return waitForRetry("rate-limit", waitMs, signal);
179
- }
1
+ import {
2
+ DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
3
+ DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS,
4
+ DEFAULT_WAITING_ENV_VAR,
5
+ FREEZING_ENV_VAR,
6
+ MAX_RETRY_ENV_VAR,
7
+ RETRY_INTERVAL_ENV_VAR,
8
+ } from "./constants.js";
9
+ import { state } from "./state.js";
10
+ import {
11
+ createWaitId,
12
+ emitWaitTelemetry,
13
+ waitModel,
14
+ type LimitsWaitWaitEndPayload,
15
+ type LimitsWaitWaitOutcome,
16
+ type LimitsWaitWaitStartPayload,
17
+ type WaitTelemetryOptions,
18
+ } from "./telemetry.js";
19
+ import type { RetryReason } from "./types.js";
20
+
21
+ export function formatDuration(ms: number): string {
22
+ const totalSecs = Math.max(0, Math.ceil(ms / 1_000));
23
+ const hours = Math.floor(totalSecs / 3_600);
24
+ const mins = Math.floor((totalSecs % 3_600) / 60);
25
+ const secs = (totalSecs % 60).toString().padStart(2, "0");
26
+ return hours > 0 ? `${hours}h ${mins}m ${secs}s` : `${mins}m ${secs}s`;
27
+ }
28
+
29
+ export function formatErrorDetail(errorMessage: string, maxLength = 500): string {
30
+ const oneLine = errorMessage.replace(/\s+/g, " ").trim();
31
+ if (!oneLine) return "unknown error";
32
+ return oneLine.length > maxLength ? `${oneLine.slice(0, maxLength - 1)}…` : oneLine;
33
+ }
34
+
35
+ export function reasonLabel(reason: RetryReason): string {
36
+ if (reason === "overloaded") return "Server overloaded";
37
+ if (reason === "authentication") return "Authentication refresh pending";
38
+ if (reason === "model-frozen") return "Model frozen after error";
39
+ if (reason === "network") return "Network/timeout error";
40
+ if (reason === "retry") return "Retrying after error";
41
+ return "Rate limited";
42
+ }
43
+
44
+ function envBoolean(raw: string | undefined, defaultValue: boolean): boolean {
45
+ if (raw === undefined) return defaultValue;
46
+ const value = raw.trim().toLowerCase();
47
+ return !(value === "false" || value === "0" || value === "no" || value === "off");
48
+ }
49
+
50
+ function envNonNegativeInteger(raw: string | undefined, defaultValue: number, maximum = Number.MAX_SAFE_INTEGER): number {
51
+ if (raw === undefined || !/^\d+$/.test(raw.trim())) return defaultValue;
52
+ const value = Number(raw);
53
+ return Number.isSafeInteger(value) ? Math.min(value, maximum) : defaultValue;
54
+ }
55
+
56
+ export function freezingEnabled(): boolean {
57
+ return envBoolean(process.env[FREEZING_ENV_VAR], true);
58
+ }
59
+
60
+ /** Load unknown-error retry settings once per extension instance/reload. */
61
+ export function loadUnknownErrorRetrySettings(): void {
62
+ state.unknownErrorWaitingEnabled = envBoolean(process.env[DEFAULT_WAITING_ENV_VAR], true);
63
+ const maxRetries = envNonNegativeInteger(
64
+ process.env[MAX_RETRY_ENV_VAR],
65
+ DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
66
+ Number.MAX_SAFE_INTEGER - 1,
67
+ );
68
+ // The first failed request is not itself a retry.
69
+ state.nonRetryableMaxAttempts = maxRetries + 1;
70
+
71
+ // PI_LIMITS_WAIT_RETRY_INTERVAL is expressed in seconds; internally waits use ms.
72
+ const intervalSeconds = envNonNegativeInteger(
73
+ process.env[RETRY_INTERVAL_ENV_VAR],
74
+ DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS / 1_000,
75
+ // Node timers cannot reliably wait longer than this in one timeout.
76
+ Math.floor(2_147_483_647 / 1_000),
77
+ );
78
+ state.nonRetryableRetryDelayMs = intervalSeconds * 1_000;
79
+ }
80
+
81
+ function countdownText(reason: RetryReason, deadline: number, allowSkip: boolean): string {
82
+ const remaining = Math.max(0, deadline - Date.now());
83
+ const totalSecs = Math.ceil(remaining / 1_000);
84
+ const mins = Math.floor(totalSecs / 60);
85
+ const secs = (totalSecs % 60).toString().padStart(2, "0");
86
+ return (
87
+ `⏳ ${reasonLabel(reason)} — next retry in ${mins}m ${secs}s` +
88
+ (allowSkip ? " (Enter to retry now)" : "")
89
+ );
90
+ }
91
+
92
+ export function showAmbientRetryStatus(reason: RetryReason, waitMs: number): void {
93
+ const ctx = state.sharedCtx;
94
+ if (!ctx) return;
95
+
96
+ state.ambientStatusCleanup?.();
97
+ if (waitMs <= 0) return;
98
+
99
+ const deadline = Date.now() + waitMs;
100
+ const tick = () => {
101
+ if (Date.now() >= deadline) {
102
+ state.ambientStatusCleanup?.();
103
+ return;
104
+ }
105
+ ctx.ui.setWorkingMessage(countdownText(reason, deadline, false));
106
+ };
107
+
108
+ tick();
109
+ const ticker = setInterval(tick, 1_000);
110
+ state.ambientStatusCleanup = () => {
111
+ clearInterval(ticker);
112
+ state.ambientStatusCleanup = undefined;
113
+ ctx.ui.setWorkingMessage();
114
+ };
115
+ }
116
+
117
+ export function clearAmbientRetryStatus(): void {
118
+ state.ambientStatusCleanup?.();
119
+ }
120
+
121
+ export function clearModelStatus(): void {
122
+ state.modelStatusCleanup?.();
123
+ }
124
+
125
+ export function waitForRetry(
126
+ reason: RetryReason,
127
+ waitMs: number,
128
+ signal?: AbortSignal,
129
+ telemetry?: WaitTelemetryOptions,
130
+ ): Promise<LimitsWaitWaitOutcome> {
131
+ if (waitMs <= 0) return Promise.resolve(signal?.aborted ? "aborted" : "waited");
132
+
133
+ const startedAt = Date.now();
134
+ const plannedDeadline = startedAt + waitMs;
135
+ const waitId = createWaitId();
136
+ const model = waitModel(telemetry?.model);
137
+ const events = telemetry?.events ?? state.extensionApi?.events;
138
+ const common = {
139
+ version: 1 as const,
140
+ waitId,
141
+ ...(telemetry?.periodId ? { periodId: telemetry.periodId } : {}),
142
+ reason,
143
+ plannedDurationMs: waitMs,
144
+ plannedDeadline,
145
+ startedAt,
146
+ ...(model ? { model } : {}),
147
+ ...(telemetry?.error ? { error: formatErrorDetail(telemetry.error) } : {}),
148
+ };
149
+ emitWaitTelemetry(events, { ...common, phase: "start" } satisfies LimitsWaitWaitStartPayload);
150
+
151
+ return new Promise((resolve) => {
152
+ const ctx = state.sharedCtx;
153
+ let done = false;
154
+ let unsubInput: (() => void) | undefined;
155
+ let ticker: ReturnType<typeof setInterval> | undefined;
156
+ let timer: ReturnType<typeof setTimeout> | undefined;
157
+
158
+ const onAbort = () => settle("aborted");
159
+
160
+ function cleanup() {
161
+ if (ticker) clearInterval(ticker);
162
+ if (timer) clearTimeout(timer);
163
+ signal?.removeEventListener("abort", onAbort);
164
+ try { unsubInput?.(); } catch { /* UI unavailable */ }
165
+ try { ctx?.ui.setWorkingMessage(); } catch { /* UI unavailable */ }
166
+ try { clearAmbientRetryStatus(); } catch { /* UI unavailable */ }
167
+ }
168
+
169
+ function settle(outcome: LimitsWaitWaitOutcome) {
170
+ if (done) return;
171
+ done = true;
172
+ cleanup();
173
+ const endedAt = Date.now();
174
+ const actualElapsedMs = Math.max(0, endedAt - startedAt);
175
+ try { telemetry?.onEnd?.(actualElapsedMs, outcome); } catch { /* observational callback */ }
176
+ emitWaitTelemetry(events, {
177
+ ...common,
178
+ phase: "end",
179
+ endedAt,
180
+ actualElapsedMs,
181
+ outcome,
182
+ } satisfies LimitsWaitWaitEndPayload);
183
+ resolve(outcome);
184
+ }
185
+
186
+ if (signal?.aborted) {
187
+ settle("aborted");
188
+ return;
189
+ }
190
+
191
+ try {
192
+ const unsubscribe = ctx?.ui.onTerminalInput((data) => {
193
+ if (done) return undefined;
194
+ if (data === "\r" || data === "\n") {
195
+ settle("skipped");
196
+ return { consume: true };
197
+ }
198
+ if (data === "\x1b") {
199
+ settle("aborted");
200
+ return { consume: true };
201
+ }
202
+ return undefined;
203
+ });
204
+ if (done) unsubscribe?.();
205
+ else unsubInput = unsubscribe;
206
+ } catch { /* UI unavailable */ }
207
+ if (done) return;
208
+
209
+ signal?.addEventListener("abort", onAbort);
210
+ if (signal?.aborted) {
211
+ settle("aborted");
212
+ return;
213
+ }
214
+
215
+ const tick = () => {
216
+ try { ctx?.ui.setWorkingMessage(countdownText(reason, plannedDeadline, Boolean(unsubInput))); } catch { /* UI unavailable */ }
217
+ };
218
+
219
+ tick();
220
+ if (done) return;
221
+ ticker = setInterval(() => {
222
+ if (Date.now() >= plannedDeadline) settle("waited");
223
+ else tick();
224
+ }, 1_000);
225
+ timer = setTimeout(() => settle("waited"), Math.max(0, plannedDeadline - Date.now()));
226
+ });
227
+ }
228
+
229
+ export function waitForRateLimit(
230
+ waitMs: number,
231
+ signal?: AbortSignal,
232
+ ): Promise<"waited" | "skipped" | "aborted"> {
233
+ return waitForRetry("rate-limit", waitMs, signal);
234
+ }