agent-afk 5.84.2 → 5.84.4

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/providers/anthropic-direct/query/retry-layer.d.ts

@@ -23,6 +23,7 @@ export declare class RetryLayer {
     private readonly surface?;
     private refreshPromise;
     private usageLimitWaitPromise;
+    private credentialSnapshotStale;
     constructor(opts: RetryLayerOptions);
     get client(): Anthropic;
     private rotateHeaders;

package/dist/cli/slash/commands/retry.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../types.js';
+export declare const retryCmd: SlashCommand;