agent-afk 5.84.3 → 5.84.5

package/dist/agent/providers/anthropic-direct/loop/outcomes.d.ts

@@ -0,0 +1,16 @@
+import type { TurnResult } from '../types.js';
+export type RetryReason = 'ttfb' | 'overload' | 'stream-incomplete';
+export type RoundOutcome = {
+    kind: 'terminated';
+} | {
+    kind: 'retry';
+    reason: RetryReason;
+} | {
+    kind: 'overload-exhausted';
+} | {
+    kind: 'translator-errored';
+} | {
+    kind: 'streamed';
+    turnResult: TurnResult | null;
+};
+export type RetryOutcome = 'continue' | 'terminated';

package/dist/agent/providers/anthropic-direct/loop/retry-budget.d.ts

@@ -0,0 +1,15 @@
+export declare const OVERLOAD_MAX_RETRIES = 3;
+export declare const OVERLOAD_BASE_DELAY_MS = 5000;
+export declare const STREAM_INCOMPLETE_MAX_RETRIES = 2;
+export declare const STREAM_INCOMPLETE_BASE_DELAY_MS = 1000;
+export declare function isTransientServerError(err: Error): boolean;
+export declare function isOverloadedErrorEvent(err: unknown): boolean;
+export declare class RoundRetryBudget {
+    overloadRetries: number;
+    streamIncompleteRetries: number;
+    ttfbRetried: boolean;
+    canRetryOverload(): boolean;
+    canRetryStreamIncomplete(): boolean;
+    canRetryTtfb(): boolean;
+    reset(): void;
+}

package/dist/agent/providers/anthropic-direct/loop/round-request.d.ts

@@ -0,0 +1,28 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { AnthropicToolDef, RunTurnInput, WireToolDef } from '../types.js';
+import { type FirstByteTimeoutHandle } from '../../shared/first-byte-timeout.js';
+import { type StreamStallHandle } from '../../shared/stream-stall-timeout.js';
+import { type RoundRetryBudget } from './retry-budget.js';
+import type { TurnAccumulator } from './turn-accumulator.js';
+export declare function toWireTool(tool: AnthropicToolDef): WireToolDef;
+export interface OpenRoundTransport {
+    kind: 'opened';
+    events: AsyncIterable<unknown>;
+    ttfb: FirstByteTimeoutHandle;
+    stall: StreamStallHandle;
+    requestStartedAt: number;
+}
+export type OpenRoundResult = OpenRoundTransport | {
+    kind: 'retry-ttfb';
+    requestStartedAt: number;
+} | {
+    kind: 'terminated';
+};
+export interface OpenRoundContext {
+    input: RunTurnInput;
+    turn: TurnAccumulator;
+    retry: RoundRetryBudget;
+    ttfbTimeoutMs: number;
+    stallTimeoutMs: number;
+}
+export declare function openRound({ input, turn, retry, ttfbTimeoutMs, stallTimeoutMs, }: OpenRoundContext): AsyncGenerator<ProviderEvent, OpenRoundResult, void>;

package/dist/agent/providers/anthropic-direct/loop/round-retry.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+import type { RetryOutcome, RetryReason } from './outcomes.js';
+import { type RoundRetryBudget } from './retry-budget.js';
+import type { TurnAccumulator } from './turn-accumulator.js';
+export interface RoundRetryContext {
+    input: RunTurnInput;
+    turn: TurnAccumulator;
+    retry: RoundRetryBudget;
+    requestStartedAt: number;
+}
+export declare function handleRoundRetry(reason: RetryReason, { input, turn, retry, requestStartedAt }: RoundRetryContext): AsyncGenerator<ProviderEvent, RetryOutcome, void>;

package/dist/agent/providers/anthropic-direct/loop/stream-consumer.d.ts

@@ -0,0 +1,18 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+import type { FirstByteTimeoutHandle } from '../../shared/first-byte-timeout.js';
+import { type StreamStallHandle } from '../../shared/stream-stall-timeout.js';
+import type { RoundRetryBudget } from './retry-budget.js';
+import type { RoundOutcome } from './outcomes.js';
+import type { TurnAccumulator } from './turn-accumulator.js';
+export interface StreamConsumerContext {
+    events: AsyncIterable<unknown>;
+    input: RunTurnInput;
+    turn: TurnAccumulator;
+    retry: RoundRetryBudget;
+    ttfb: FirstByteTimeoutHandle;
+    stall: StreamStallHandle;
+    stallTimeoutMs: number;
+    requestStartedAt: number;
+}
+export declare function consumeRoundStream({ events, input, turn, retry, ttfb, stall, stallTimeoutMs, requestStartedAt, }: StreamConsumerContext): AsyncGenerator<ProviderEvent, RoundOutcome, void>;

package/dist/agent/providers/anthropic-direct/loop/thinking-diagnostic.d.ts

@@ -0,0 +1,2 @@
+import type { MessageParam } from '@anthropic-ai/sdk/resources';
+export declare function dumpThinkingDiagnostic(messages: MessageParam[], error: Error): void;

package/dist/agent/providers/anthropic-direct/loop/throttle-signals.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+export declare function awaitCreateWithThrottleSignals(createPromise: Promise<AsyncIterable<unknown>>, input: RunTurnInput): AsyncGenerator<ProviderEvent, AsyncIterable<unknown>, void>;

package/dist/agent/providers/anthropic-direct/loop/tool-dispatch.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput, ToolCall, ToolResult, TurnResult } from '../types.js';
+import type { TurnAccumulator } from './turn-accumulator.js';
+export type DispatchResult = {
+    kind: 'dispatched';
+    calls: ToolCall[];
+    results: ToolResult[];
+    startTimes: Map<string, number>;
+} | {
+    kind: 'aborted';
+};
+export declare function dispatchToolCalls(turnResult: TurnResult, input: RunTurnInput, turn: TurnAccumulator): AsyncGenerator<ProviderEvent, DispatchResult, void>;

package/dist/agent/providers/anthropic-direct/loop/tool-results.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput, ToolCall, ToolResult } from '../types.js';
+export type ToolResultsOutcome = 'committed' | 'denial-tripped';
+export declare function emitAndCommitToolResults(calls: ToolCall[], results: ToolResult[], startTimes: Map<string, number>, input: RunTurnInput): AsyncGenerator<ProviderEvent, ToolResultsOutcome, void>;

package/dist/agent/providers/anthropic-direct/loop/tool-round.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput, TurnResult } from '../types.js';
+import type { TurnAccumulator } from './turn-accumulator.js';
+export type ToolRoundOutcome = 'continue' | 'terminated';
+export declare function runToolRound(turnResult: TurnResult, input: RunTurnInput, turn: TurnAccumulator, maxIterations: number): AsyncGenerator<ProviderEvent, ToolRoundOutcome, void>;

package/dist/agent/providers/anthropic-direct/loop/turn-accumulator.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderUsage } from '../../../provider.js';
+export declare class TurnAccumulator {
+    usage: ProviderUsage;
+    iterations: number;
+    toolCallCount: number;
+    capReached: boolean;
+    readonly taskId: string;
+    readonly startedAt: number;
+    elapsedMs(): number;
+    withDuration(usage: ProviderUsage): ProviderUsage;
+    terminalUsage(): ProviderUsage;
+    addRoundUsage(roundUsage: ProviderUsage): void;
+}

package/dist/agent/providers/anthropic-direct/loop/turn-terminal.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput, TurnResult } from '../types.js';
+import type { TurnAccumulator } from './turn-accumulator.js';
+export declare function emitNonToolUseTerminal(turnResult: TurnResult, input: RunTurnInput, turn: TurnAccumulator): Generator<ProviderEvent, void, void>;

package/dist/agent/providers/anthropic-direct/loop/turn-trace.d.ts

@@ -0,0 +1,9 @@
+import type { TraceWriter } from '../../../trace/index.js';
+export declare class TurnTrace {
+    private readonly signal;
+    private readonly traceWriter;
+    private interruptedAt;
+    constructor(signal: AbortSignal, traceWriter: TraceWriter | undefined);
+    private readonly onInterrupt;
+    finish(turnElapsedMs: number): void;
+}

package/dist/agent/providers/anthropic-direct/loop.d.ts

@@ -1,9 +1,3 @@
 import type { ProviderEvent } from '../../provider.js';
-import type { AnthropicToolDef, RunTurnInput, WireToolDef } from './types.js';
-export { DEFAULT_MAX_TOOL_USE_ITERATIONS } from '../shared/tool-loop-cap.js';
-export declare function toWireTool(tool: AnthropicToolDef): WireToolDef;
-export declare const OVERLOAD_MAX_RETRIES = 3;
-export declare const STREAM_INCOMPLETE_MAX_RETRIES = 2;
-export declare function isTransientServerError(err: Error): boolean;
-export declare function isOverloadedErrorEvent(err: unknown): boolean;
+import type { RunTurnInput } from './types.js';
 export declare function runTurn(input: RunTurnInput): AsyncGenerator<ProviderEvent, void, void>;

package/dist/agent/tools/dispatcher.d.ts

@@ -62,6 +62,7 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private readonly readOnlyBash;
     private readonly maxOutputBytes;
     private repeatBreaker;
+    private readonly repeatFailureGuard;
     private denialBreaker;
     private suspectedLoopWindow;
     private readonly grantManager;
@@ -78,6 +79,7 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private checkReadOnlyBash;
     private emitPreToolUseBlock;
     private checkRepeatCircuitBreaker;
+    private checkRepeatFailureGuard;
     private observeSuspectedLoop;
     private recordForkReadDenial;
     private resetDenialBreaker;

package/dist/agent/tools/repeat-failure-guard.d.ts

@@ -0,0 +1,14 @@
+import type { ToolCall, ToolResult } from '../providers/anthropic-direct/types.js';
+export declare const REPEAT_FAILURE_REFUSAL_THRESHOLD = 3;
+export interface RepeatFailureVerdict {
+    readonly result: ToolResult;
+    readonly count: number;
+    readonly tool: string;
+}
+export declare function repeatFailureFingerprint(call: ToolCall): string;
+export declare class RepeatFailureGuard {
+    private readonly streaks;
+    check(call: ToolCall): RepeatFailureVerdict | null;
+    note(call: ToolCall, result: ToolResult): void;
+    streakFor(call: ToolCall): number;
+}

package/dist/agent/trace/events.d.ts

@@ -14,6 +14,7 @@ export declare const ToolFailureClassSchema: z.ZodEnum<{
     "hook-block": "hook-block";
     "elicitation-declined": "elicitation-declined";
     "denial-breaker": "denial-breaker";
+    "repeat-failure": "repeat-failure";
 }>;
 export declare const ToolCallCompletedPayloadSchema: z.ZodObject<{
     phase: z.ZodLiteral<"completed">;
@@ -34,6 +35,7 @@ export declare const ToolCallCompletedPayloadSchema: z.ZodObject<{
         "hook-block": "hook-block";
         "elicitation-declined": "elicitation-declined";
         "denial-breaker": "denial-breaker";
+        "repeat-failure": "repeat-failure";
     }>>;
     batchIndex: z.ZodOptional<z.ZodNumber>;
     batchSize: z.ZodOptional<z.ZodNumber>;
@@ -64,6 +66,7 @@ export declare const ToolCallPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         "hook-block": "hook-block";
         "elicitation-declined": "elicitation-declined";
         "denial-breaker": "denial-breaker";
+        "repeat-failure": "repeat-failure";
     }>>;
     batchIndex: z.ZodOptional<z.ZodNumber>;
     batchSize: z.ZodOptional<z.ZodNumber>;
@@ -138,6 +141,7 @@ export declare const SubagentFailedPayloadSchema: z.ZodObject<{
         "hook-block": "hook-block";
         "elicitation-declined": "elicitation-declined";
         "denial-breaker": "denial-breaker";
+        "repeat-failure": "repeat-failure";
     }>>;
 }, z.core.$strip>;
 export declare const SubagentCancelledPayloadSchema: z.ZodObject<{
@@ -181,6 +185,7 @@ export declare const SubagentLifecyclePayloadSchema: z.ZodDiscriminatedUnion<[z.
         "hook-block": "hook-block";
         "elicitation-declined": "elicitation-declined";
         "denial-breaker": "denial-breaker";
+        "repeat-failure": "repeat-failure";
     }>>;
 }, z.core.$strip>, z.ZodObject<{
     transition: z.ZodLiteral<"cancelled">;
@@ -585,6 +590,7 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             "hook-block": "hook-block";
             "elicitation-declined": "elicitation-declined";
             "denial-breaker": "denial-breaker";
+            "repeat-failure": "repeat-failure";
         }>>;
         batchIndex: z.ZodOptional<z.ZodNumber>;
         batchSize: z.ZodOptional<z.ZodNumber>;
@@ -652,6 +658,7 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             "hook-block": "hook-block";
             "elicitation-declined": "elicitation-declined";
             "denial-breaker": "denial-breaker";
+            "repeat-failure": "repeat-failure";
         }>>;
     }, z.core.$strip>, z.ZodObject<{
         transition: z.ZodLiteral<"cancelled">;
@@ -904,6 +911,7 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "hook-block": "hook-block";
             "elicitation-declined": "elicitation-declined";
             "denial-breaker": "denial-breaker";
+            "repeat-failure": "repeat-failure";
         }>>;
         batchIndex: z.ZodOptional<z.ZodNumber>;
         batchSize: z.ZodOptional<z.ZodNumber>;
@@ -975,6 +983,7 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "hook-block": "hook-block";
             "elicitation-declined": "elicitation-declined";
             "denial-breaker": "denial-breaker";
+            "repeat-failure": "repeat-failure";
         }>>;
     }, z.core.$strip>, z.ZodObject<{
         transition: z.ZodLiteral<"cancelled">;

package/dist/agent/trace/types.d.ts

@@ -6,7 +6,7 @@ export interface ToolCallStartedPayload {
     inputBytes: number;
     subagentId?: string;
 }
-export declare const TOOL_FAILURE_CLASSES: readonly ["policy-refusal", "timeout", "permission-denied", "hook-block", "abort", "elicitation-declined", "denial-breaker"];
+export declare const TOOL_FAILURE_CLASSES: readonly ["policy-refusal", "timeout", "permission-denied", "hook-block", "abort", "elicitation-declined", "denial-breaker", "repeat-failure"];
 export type ToolFailureClass = (typeof TOOL_FAILURE_CLASSES)[number];
 export interface ToolCallCompletedPayload {
     phase: 'completed';