@adecore/agents 0.27.3 → 0.27.5

package/dist/chat/backend.d.ts

@@ -10,6 +10,7 @@ export interface BackendLaunch {
     runtimeMode: RuntimeMode;
     resume: string | null;
     generation: number;
+    now?(): number;
     instructions: string | null;
     resumeNote: string | null;
     resumeInstructions?: string | null;
@@ -197,6 +198,7 @@ export type BackendEvent = {
         lastUuid?: string;
     };
     limit?: ChatTurnLimit;
+    replaceProcess?: boolean;
 } | {
     type: 'failed';
     message: string;

package/dist/chat/chat-session.d.ts

@@ -85,6 +85,7 @@ export declare class ChatSession {
     private readonly options;
     private readonly projector;
     private backend;
+    private replaceProcess;
     private starting;
     private pendingStart;
     private sendAfterStop;

package/dist/chat/chat-session.js

@@ -43,6 +43,7 @@ export class ChatSession {
     options;
     projector;
     backend = null;
+    replaceProcess = false;
     starting = null;
     pendingStart = null;
     sendAfterStop = false;
@@ -1564,7 +1565,8 @@ export class ChatSession {
     }
     requiresReplacement() {
         return (this.backend !== null &&
-            (JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
+            (this.replaceProcess ||
+                JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
                 this.info.runtimeMode !== this.launchedRuntimeMode ||
                 this.info.account !== this.launchedAccount ||
                 this.info.cwd !== this.launchedCwd ||
@@ -1626,6 +1628,7 @@ export class ChatSession {
             runtimeMode: info.runtimeMode,
             resume: info.agentSessionId,
             generation,
+            now: () => this.options.limitResume?.now() ?? (this.options.clock ?? systemClock).now(),
             saveGeneratedImage: this.options.saveGeneratedImage,
             instructions: this.options.instructions?.() ?? null,
             resumeNote: this.options.resumeNote?.() ?? null,
@@ -1650,6 +1653,7 @@ export class ChatSession {
         }
         const backend = made.backend;
         this.backend = backend;
+        this.replaceProcess = false;
         this.emit([this.thread.patchInfo({ running: true, effectiveRuntimeMode: undefined, permissionMode: undefined })]);
         let started;
         try {
@@ -1730,6 +1734,9 @@ export class ChatSession {
             if (event.promptId !== undefined) {
                 this.staleResults = 0;
             }
+            if (event.replaceProcess === true) {
+                this.replaceProcess = true;
+            }
             const promptId = event.promptId ?? this.submission?.input.promptId;
             if (promptId !== undefined) {
                 this.acceptPrompt(promptId);

package/dist/chat/claude-backend.js

@@ -32,7 +32,7 @@ export class ClaudeBackend {
         this.launch = launch;
         this.host = host;
         this.allowedTools = options.allowedTools ?? [];
-        this.protocol = new ClaudeProtocol(launch.goal ?? null);
+        this.protocol = new ClaudeProtocol(launch.goal ?? null, launch.now);
     }
     get running() {
         return this.child !== null;

package/dist/chat/claude-protocol.d.ts

@@ -3,6 +3,7 @@ import type { ApprovalDecision, BackendEvent } from './backend.ts';
 export declare function claudeGoalFromCommand(text: string, current: ChatGoal | null): ChatGoal | null | undefined;
 export declare function claudeGoalCheck(text: string, current: ChatGoal | null): ChatGoal | undefined;
 export declare class ClaudeProtocol {
+    private readonly now;
     private promptId;
     private readonly pending;
     private streamMessageId;
@@ -18,13 +19,14 @@ export declare class ClaudeProtocol {
     private readonly subagentModels;
     private apiError;
     private readonly refusedWindows;
+    private readonly refusedResets;
     private readonly stopRequests;
     private readonly steerIds;
     private goal;
     private goalAnswered;
     private interrupting;
     private readonly backgroundAgents;
-    constructor(goal?: ChatGoal | null);
+    constructor(goal?: ChatGoal | null, now?: () => number);
     noteInterrupt(): void;
     private setGoal;
     beginSteer(promptId: string): void;
@@ -50,6 +52,7 @@ export declare class ClaudeProtocol {
     private handleUser;
     private handleResult;
     private noteRefusal;
+    private expireRefusedResets;
     private limit;
     private handleControlRequest;
     private textRef;

package/dist/chat/claude-protocol.js

@@ -153,6 +153,7 @@ export function claudeGoalCheck(text, current) {
  * belongs to one process, so a resumed CLI that numbers its messages from the start gets its own.
  */
 export class ClaudeProtocol {
+    now;
     promptId = null;
     pending = new Map();
     streamMessageId = null;
@@ -174,6 +175,8 @@ export class ClaudeProtocol {
     // Only main-chain errors classify the turn; each plan window can refuse it independently.
     apiError = null;
     refusedWindows = new Map();
+    // Sparse refusals can omit a reset; cached metadata alone must never classify a later 429.
+    refusedResets = new Map();
     // The task each `stop_task` request named, so an error answer finds it again.
     stopRequests = new Map();
     steerIds = new Set();
@@ -184,8 +187,9 @@ export class ClaudeProtocol {
     interrupting = false;
     // Background subagents still at work; Claude Code holds a goal's check until they report.
     backgroundAgents = new Set();
-    constructor(goal = null) {
+    constructor(goal = null, now = () => Date.now()) {
         this.goal = goal;
+        this.now = now;
     }
     /* A stop is on its way; the turn it ends leaves the goal set but nobody working on it. */
     noteInterrupt() {
@@ -204,6 +208,7 @@ export class ClaudeProtocol {
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
+        this.expireRefusedResets();
         this.lastUuid = null;
     }
     handle(frame) {
@@ -713,6 +718,10 @@ export class ClaudeProtocol {
         const lastUuid = this.lastUuid;
         this.lastUuid = null;
         const limit = failed ? this.limit() : null;
+        const replaceProcess = failed && this.apiError === 'authentication_failed';
+        if (limit?.kind !== 'usage') {
+            this.refusedResets.clear();
+        }
         this.apiError = null;
         this.refusedWindows.clear();
         // Before the turn ends, so whoever settles work on that end already reads where the goal stands.
@@ -724,21 +733,41 @@ export class ClaudeProtocol {
             costUsd: num(frame.total_cost_usd),
             ...(failed ? { error: errors[0] ?? str(frame.result) ?? `The turn ended with ${str(frame.subtype) ?? 'an error'}` } : {}),
             ...(lastUuid === null ? {} : { native: { lastUuid } }),
-            ...(limit === null ? {} : { limit })
+            ...(limit === null ? {} : { limit }),
+            ...(replaceProcess ? { replaceProcess: true } : {})
         });
     }
     noteRefusal(info) {
         if (!isRecord(info) || typeof info.status !== 'string') {
             return;
         }
-        const window = str(info.rateLimitType) ?? 'unknown';
+        this.expireRefusedResets();
+        const namedWindow = str(info.rateLimitType);
+        const window = namedWindow ?? 'unknown';
         const overageAllowed = info.overageStatus === 'allowed' || info.overageStatus === 'allowed_warning' || info.isUsingOverage === true || info.overageInUse === true;
         if (info.status === 'rejected' && !overageAllowed) {
             const resetsAt = typeof info.resetsAt === 'number' ? info.resetsAt * 1000 : NaN;
-            this.refusedWindows.set(window, Number.isFinite(resetsAt) && resetsAt > 0 && resetsAt < 8.64e15 ? resetsAt : null);
+            const validReset = Number.isFinite(resetsAt) && resetsAt > this.now() && resetsAt < 8.64e15 ? resetsAt : null;
+            const reset = validReset ?? (info.resetsAt === undefined && namedWindow ? (this.refusedResets.get(window) ?? null) : null);
+            this.refusedWindows.set(window, reset);
+            if (namedWindow && reset !== null && reset > this.now()) {
+                this.refusedResets.set(window, reset);
+            }
+            else {
+                this.refusedResets.delete(window);
+            }
         }
         else if (info.status === 'allowed' || info.status === 'allowed_warning' || overageAllowed) {
             this.refusedWindows.delete(window);
+            this.refusedResets.delete(window);
+        }
+    }
+    expireRefusedResets() {
+        const now = this.now();
+        for (const [window, reset] of this.refusedResets) {
+            if (reset <= now) {
+                this.refusedResets.delete(window);
+            }
         }
     }
     /*
@@ -750,7 +779,7 @@ export class ClaudeProtocol {
         if (this.refusedWindows.size > 0) {
             let resetsAt = 0;
             for (const reset of this.refusedWindows.values()) {
-                if (reset === null) {
+                if (reset === null || reset <= this.now()) {
                     return { kind: 'usage' };
                 }
                 resetsAt = Math.max(resetsAt, reset);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.27.3",
+  "version": "0.27.5",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,8 +81,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.27.3",
-    "@adecore/intelligent-ui": "0.27.3",
+    "@adecore/agent-contracts": "0.27.5",
+    "@adecore/intelligent-ui": "0.27.5",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/backend.ts

@@ -35,6 +35,8 @@ export interface BackendLaunch {
     // How often this chat started a CLI; a protocol that numbers its own requests from zero
     // needs it to keep the ids of one process apart from those of the one before.
     generation: number;
+    // Shares the host clock with expiry checks when a test advances time by hand.
+    now?(): number;
     // What the agent is told once, at the start of a process: a system prompt, or a new thread's developer instructions.
     instructions: string | null;
     // The part of it a resumed thread has to hear again in front of its next prompt, for a CLI that ignores new
@@ -182,6 +184,8 @@ export type BackendEvent =
           error?: string;
           native?: { turnId?: string; lastUuid?: string };
           limit?: ChatTurnLimit;
+          // The next prompt needs fresh process credentials, once native work and requests have settled.
+          replaceProcess?: boolean;
       }
     // The CLI could not be reached or refused the request; the turn ends and the chat needs a new one.
     | { type: 'failed'; message: string; processAlive?: boolean }

package/src/chat/chat-session.ts

@@ -170,6 +170,7 @@ export class ChatSession {
     private readonly options: ChatSessionOptions;
     private readonly projector: ThreadProjector;
     private backend: ChatBackend | null = null;
+    private replaceProcess = false;
     private starting: Promise<ChatBackend> | null = null;
     private pendingStart: { turnId: string; warning: unknown } | null = null;
     private sendAfterStop = false;
@@ -1805,7 +1806,8 @@ export class ChatSession {
     private requiresReplacement(): boolean {
         return (
             this.backend !== null &&
-            (JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
+            (this.replaceProcess ||
+                JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
                 this.info.runtimeMode !== this.launchedRuntimeMode ||
                 this.info.account !== this.launchedAccount ||
                 this.info.cwd !== this.launchedCwd ||
@@ -1874,6 +1876,7 @@ export class ChatSession {
             runtimeMode: info.runtimeMode,
             resume: info.agentSessionId,
             generation,
+            now: () => this.options.limitResume?.now() ?? (this.options.clock ?? systemClock).now(),
             saveGeneratedImage: this.options.saveGeneratedImage,
             instructions: this.options.instructions?.() ?? null,
             resumeNote: this.options.resumeNote?.() ?? null,
@@ -1897,6 +1900,7 @@ export class ChatSession {
         }
         const backend = made.backend;
         this.backend = backend;
+        this.replaceProcess = false;
         this.emit([this.thread.patchInfo({ running: true, effectiveRuntimeMode: undefined, permissionMode: undefined })]);
         let started: Promise<void>;
         try {
@@ -1980,6 +1984,9 @@ export class ChatSession {
             if (event.promptId !== undefined) {
                 this.staleResults = 0;
             }
+            if (event.replaceProcess === true) {
+                this.replaceProcess = true;
+            }
             const promptId = event.promptId ?? this.submission?.input.promptId;
             if (promptId !== undefined) {
                 this.acceptPrompt(promptId);

package/src/chat/claude-backend.ts

@@ -41,7 +41,7 @@ export class ClaudeBackend implements ChatBackend {
         this.launch = launch;
         this.host = host;
         this.allowedTools = options.allowedTools ?? [];
-        this.protocol = new ClaudeProtocol(launch.goal ?? null);
+        this.protocol = new ClaudeProtocol(launch.goal ?? null, launch.now);
     }
 
     get running(): boolean {

package/src/chat/claude-protocol.ts

@@ -187,6 +187,7 @@ export function claudeGoalCheck(text: string, current: ChatGoal | null): ChatGoa
  * belongs to one process, so a resumed CLI that numbers its messages from the start gets its own.
  */
 export class ClaudeProtocol {
+    private readonly now: () => number;
     private promptId: string | null = null;
     private readonly pending = new Map<string, Pending>();
     private streamMessageId: string | null = null;
@@ -208,6 +209,8 @@ export class ClaudeProtocol {
     // Only main-chain errors classify the turn; each plan window can refuse it independently.
     private apiError: string | null = null;
     private readonly refusedWindows = new Map<string, number | null>();
+    // Sparse refusals can omit a reset; cached metadata alone must never classify a later 429.
+    private readonly refusedResets = new Map<string, number>();
 
     // The task each `stop_task` request named, so an error answer finds it again.
     private readonly stopRequests = new Map<string, string>();
@@ -221,8 +224,9 @@ export class ClaudeProtocol {
     // Background subagents still at work; Claude Code holds a goal's check until they report.
     private readonly backgroundAgents = new Set<string>();
 
-    constructor(goal: ChatGoal | null = null) {
+    constructor(goal: ChatGoal | null = null, now: () => number = () => Date.now()) {
         this.goal = goal;
+        this.now = now;
     }
 
     /* A stop is on its way; the turn it ends leaves the goal set but nobody working on it. */
@@ -245,6 +249,7 @@ export class ClaudeProtocol {
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
+        this.expireRefusedResets();
         this.lastUuid = null;
     }
 
@@ -765,6 +770,10 @@ export class ClaudeProtocol {
         const lastUuid = this.lastUuid;
         this.lastUuid = null;
         const limit = failed ? this.limit() : null;
+        const replaceProcess = failed && this.apiError === 'authentication_failed';
+        if (limit?.kind !== 'usage') {
+            this.refusedResets.clear();
+        }
         this.apiError = null;
         this.refusedWindows.clear();
         // Before the turn ends, so whoever settles work on that end already reads where the goal stands.
@@ -776,7 +785,8 @@ export class ClaudeProtocol {
             costUsd: num(frame.total_cost_usd),
             ...(failed ? { error: errors[0] ?? str(frame.result) ?? `The turn ended with ${str(frame.subtype) ?? 'an error'}` } : {}),
             ...(lastUuid === null ? {} : { native: { lastUuid } }),
-            ...(limit === null ? {} : { limit })
+            ...(limit === null ? {} : { limit }),
+            ...(replaceProcess ? { replaceProcess: true } : {})
         });
     }
 
@@ -784,14 +794,33 @@ export class ClaudeProtocol {
         if (!isRecord(info) || typeof info.status !== 'string') {
             return;
         }
-        const window = str(info.rateLimitType) ?? 'unknown';
+        this.expireRefusedResets();
+        const namedWindow = str(info.rateLimitType);
+        const window = namedWindow ?? 'unknown';
         const overageAllowed =
             info.overageStatus === 'allowed' || info.overageStatus === 'allowed_warning' || info.isUsingOverage === true || info.overageInUse === true;
         if (info.status === 'rejected' && !overageAllowed) {
             const resetsAt = typeof info.resetsAt === 'number' ? info.resetsAt * 1000 : NaN;
-            this.refusedWindows.set(window, Number.isFinite(resetsAt) && resetsAt > 0 && resetsAt < 8.64e15 ? resetsAt : null);
+            const validReset = Number.isFinite(resetsAt) && resetsAt > this.now() && resetsAt < 8.64e15 ? resetsAt : null;
+            const reset = validReset ?? (info.resetsAt === undefined && namedWindow ? (this.refusedResets.get(window) ?? null) : null);
+            this.refusedWindows.set(window, reset);
+            if (namedWindow && reset !== null && reset > this.now()) {
+                this.refusedResets.set(window, reset);
+            } else {
+                this.refusedResets.delete(window);
+            }
         } else if (info.status === 'allowed' || info.status === 'allowed_warning' || overageAllowed) {
             this.refusedWindows.delete(window);
+            this.refusedResets.delete(window);
+        }
+    }
+
+    private expireRefusedResets(): void {
+        const now = this.now();
+        for (const [window, reset] of this.refusedResets) {
+            if (reset <= now) {
+                this.refusedResets.delete(window);
+            }
         }
     }
 
@@ -804,7 +833,7 @@ export class ClaudeProtocol {
         if (this.refusedWindows.size > 0) {
             let resetsAt = 0;
             for (const reset of this.refusedWindows.values()) {
-                if (reset === null) {
+                if (reset === null || reset <= this.now()) {
                     return { kind: 'usage' };
                 }
                 resetsAt = Math.max(resetsAt, reset);