agent-afk 5.31.2 → 5.33.0

package/dist/agent/provider.d.ts

@@ -87,6 +87,8 @@ export type ProviderEvent = {
     truncated?: boolean;
     sessionId?: string;
     toolName?: string;
+    batchIndex?: number;
+    batchSize?: number;
 } | {
     type: 'tool.diff';
     toolUseId: string;

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

@@ -1,9 +1,9 @@
 import type { MessageParam } from '@anthropic-ai/sdk/resources';
 import type { AnthropicMessagesCreateParams } from './types.js';
-export declare const COMPACT_SYSTEM_PROMPT: string;
-export declare const COMPACT_SUMMARY_HEADER = "[Compacted summary of earlier conversation]";
-export declare const COMPACT_ACK_TEXT = "Acknowledged. Continuing from the summary above.";
+import { COMPACT_ACK_TEXT, COMPACT_SUMMARY_HEADER, COMPACT_SYSTEM_PROMPT, type CompactionOps } from '../shared/compaction.js';
+export { COMPACT_ACK_TEXT, COMPACT_SUMMARY_HEADER, COMPACT_SYSTEM_PROMPT };
 export declare function isFreshUserTurn(msg: MessageParam): boolean;
+export declare const anthropicCompactionOps: CompactionOps<MessageParam>;
 export declare function findCompactionBoundary(messages: ReadonlyArray<MessageParam>, keepLastN: number): number;
 export declare function buildSummarizationRequest(olderMessages: ReadonlyArray<MessageParam>, model: string, maxTokens: number): AnthropicMessagesCreateParams;
 export declare function applyCompaction(messages: ReadonlyArray<MessageParam>, boundary: number, summaryText: string): MessageParam[];

package/dist/agent/providers/anthropic-direct/resolve-params.d.ts

@@ -1,7 +1,7 @@
 import type { MessageParam, ThinkingConfigParam } from '@anthropic-ai/sdk/resources';
 import type { AgentConfig, ResumeHistoryTurn } from '../../types/config-types.js';
 import type { EffortLevel, ThinkingConfig } from '../../types/sdk-types.js';
-export declare function resolveAutoCompactThreshold(autoCompact: AgentConfig['autoCompact']): number | undefined;
+export { resolveAutoCompactThreshold } from '../shared/auto-compact.js';
 export declare function resolveMaxTokens(config: AgentConfig, model: string): number;
 export declare function resumeHistoryToMessages(history: ResumeHistoryTurn[] | undefined): MessageParam[] | undefined;
 export declare function resolveThinkingParam(tc: ThinkingConfig, maxTokens: number, model?: string): ThinkingConfigParam;

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

@@ -17,6 +17,8 @@ export interface ToolResult {
     truncated?: boolean;
     circuitBreaker?: boolean;
     failureClass?: ToolFailureClass;
+    batchIndex?: number;
+    batchSize?: number;
     render?: RenderHints;
     testResult?: import('../../tools/handlers/test-runner-detector.js').TestResult;
     image?: {

package/dist/agent/providers/openai-compatible/compact.d.ts

@@ -0,0 +1,19 @@
+import type { ProviderCompactResult } from '../../provider.js';
+import type { TraceWriter } from '../../trace/index.js';
+import type { CompactionTrigger } from '../../trace/types.js';
+import { type CompactionOps } from '../shared/compaction.js';
+import type { OpenAIMessage } from './messages.js';
+export declare function isFreshUserTurn(msg: OpenAIMessage): boolean;
+export declare const openaiCompactionOps: CompactionOps<OpenAIMessage>;
+export declare function readKeepLastN(): number;
+export interface CompactOpenAIHistoryDeps {
+    priorTurns: OpenAIMessage[];
+    summarize: (transcript: string, signal: AbortSignal) => Promise<string>;
+    isClosed: boolean;
+    isIdle: boolean;
+    beginAbort: () => AbortController;
+    clearAbort: (controller: AbortController) => void;
+    trigger?: CompactionTrigger;
+    traceWriter?: TraceWriter;
+}
+export declare function compactOpenAIHistory(deps: CompactOpenAIHistoryDeps): Promise<ProviderCompactResult>;

package/dist/agent/providers/openai-compatible/oneshot.d.ts

@@ -13,5 +13,6 @@ export interface OpenAIOneShotInput {
     maxTokens?: number;
     signal?: AbortSignal;
     clientFactory?: OneShotOpenAIClientFactory;
+    client?: OpenAI;
 }
 export declare function oneShotChatCompletion(input: OpenAIOneShotInput): Promise<string>;

package/dist/agent/providers/openai-compatible/query.d.ts

@@ -1,6 +1,6 @@
 import type { AgentConfig } from '../../types/config-types.js';
 import type { TraceWriter } from '../../trace/index.js';
-import type { ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderContextUsage, ProviderRewindResult, ProviderModelInfo, ProviderCommandInfo, ProviderAgentInfo, ProviderMcpServerStatus, ProviderAccountInfo } from '../../provider.js';
+import type { ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderContextUsage, ProviderRewindResult, ProviderModelInfo, ProviderCommandInfo, ProviderAgentInfo, ProviderMcpServerStatus, ProviderAccountInfo, ProviderCompactResult } from '../../provider.js';
 import { type OpenAIAuthResolution, type AuthResolverDeps } from './auth.js';
 import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
 import { resolveReasoningEffort } from './query/model-params.js';
@@ -40,6 +40,7 @@ export declare class OpenAICompatibleQuery implements ProviderQuery {
     private closeResolve;
     private readonly closedPromise;
     private lastUsage;
+    private readonly autoCompactThreshold;
     constructor(opts: OpenAICompatibleQueryOptions);
     private activeOpenAITools;
     [Symbol.asyncIterator](): AsyncIterator<ProviderEvent>;
@@ -50,6 +51,8 @@ export declare class OpenAICompatibleQuery implements ProviderQuery {
     private runIteration;
     private dispatchAndAppend;
     interrupt(): Promise<void>;
+    compact(): Promise<ProviderCompactResult>;
+    private compactHistory;
     setModel(model?: string): Promise<void>;
     setPermissionMode(mode: string): Promise<void>;
     setCwd(cwd: string): void;

package/dist/agent/providers/shared/auto-compact.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderUsage } from '../../provider.js';
+import type { AgentConfig } from '../../types/config-types.js';
 export declare function computeUsedTokens(usage: Partial<ProviderUsage>): number;
 export declare function contextWindowTokensUsed(usage: Partial<ProviderUsage>): number;
 export type ContextUsageApiBreakdown = {
@@ -13,3 +14,5 @@ export interface ContextUsageFields {
 }
 export declare function buildContextUsageFields(last: ProviderUsage | null | undefined): ContextUsageFields;
 export declare function shouldAutoCompact(usedTokens: number, contextLimit: number, threshold: number): boolean;
+export declare const DEFAULT_AUTO_COMPACT_THRESHOLD = 0.9;
+export declare function resolveAutoCompactThreshold(autoCompact: AgentConfig['autoCompact']): number | undefined;

package/dist/agent/providers/shared/compaction.d.ts

@@ -0,0 +1,36 @@
+import type { ProviderCompactResult } from '../../provider.js';
+export declare const COMPACT_SYSTEM_PROMPT: string;
+export declare const COMPACT_SUMMARY_HEADER = "[Compacted summary of earlier conversation]";
+export declare const COMPACT_ACK_TEXT = "Acknowledged. Continuing from the summary above.";
+export declare function wrapTranscriptForSummary(transcript: string): string;
+export declare const DEFAULT_COMPACT_TIMEOUT_MS = 60000;
+export interface CompactionOps<M> {
+    isFreshUserTurn(msg: M): boolean;
+    renderMessage(msg: M): string;
+    buildPreamble(summaryText: string): [userSummary: M, assistantAck: M];
+    countChars(msg: M): number;
+}
+export declare function findCompactionBoundary<M>(messages: ReadonlyArray<M>, keepLastN: number, ops: CompactionOps<M>): number;
+export declare function renderTranscript<M>(messages: ReadonlyArray<M>, ops: CompactionOps<M>): string;
+export declare function applyCompaction<M>(messages: ReadonlyArray<M>, boundary: number, summaryText: string, ops: CompactionOps<M>): M[];
+export declare function estimateTokensSaved<M>(before: ReadonlyArray<M>, boundary: number, summaryText: string, ops: CompactionOps<M>): number;
+export interface CompactionSuccess<M> {
+    olderSlice: M[];
+    summary: string;
+    keptTailCount: number;
+    keepLastN: number;
+    messagesBefore: number;
+    messagesAfter: number;
+    tokensSavedEstimate: number;
+}
+export interface CompactionCoreDeps<M> {
+    messages: M[];
+    ops: CompactionOps<M>;
+    keepLastN: number;
+    summarize(transcript: string): Promise<string>;
+    isAborted(): boolean;
+    abortInFlight?(): void;
+    timeoutMs?: number;
+    onSuccess?(info: CompactionSuccess<M>): void;
+}
+export declare function runCompactionCore<M>(deps: CompactionCoreDeps<M>): Promise<ProviderCompactResult>;

package/dist/agent/release-boundary-detect.d.ts

@@ -0,0 +1,4 @@
+import type { HookContext, HookDecision } from './hooks.js';
+export declare const RELEASE_BOUNDARY_DETECT_REASON_PREFIX = "release-boundary observe-only: publish/deploy/sync-boundary command";
+export declare function detectReleaseBoundaryCommands(command: string): string[];
+export declare function createReleaseBoundaryDetect(): (context: HookContext) => HookDecision;

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

@@ -31,6 +31,8 @@ export declare const ToolCallCompletedPayloadSchema: z.ZodObject<{
         "hook-block": "hook-block";
         "elicitation-declined": "elicitation-declined";
     }>>;
+    batchIndex: z.ZodOptional<z.ZodNumber>;
+    batchSize: z.ZodOptional<z.ZodNumber>;
     subagentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const ToolCallPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -56,6 +58,8 @@ export declare const ToolCallPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         "hook-block": "hook-block";
         "elicitation-declined": "elicitation-declined";
     }>>;
+    batchIndex: z.ZodOptional<z.ZodNumber>;
+    batchSize: z.ZodOptional<z.ZodNumber>;
     subagentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "phase">;
 export declare const HookEventNameSchema: z.ZodEnum<{
@@ -524,6 +528,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             "hook-block": "hook-block";
             "elicitation-declined": "elicitation-declined";
         }>>;
+        batchIndex: z.ZodOptional<z.ZodNumber>;
+        batchSize: z.ZodOptional<z.ZodNumber>;
         subagentId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "phase">;
 }, z.core.$strip>, z.ZodObject<{
@@ -813,6 +819,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "hook-block": "hook-block";
             "elicitation-declined": "elicitation-declined";
         }>>;
+        batchIndex: z.ZodOptional<z.ZodNumber>;
+        batchSize: z.ZodOptional<z.ZodNumber>;
         subagentId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "phase">;
 }, z.core.$strip>, z.ZodObject<{

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

@@ -18,6 +18,8 @@ export interface ToolCallCompletedPayload {
     durationMs: number;
     circuitBreaker?: boolean;
     failureClass?: ToolFailureClass;
+    batchIndex?: number;
+    batchSize?: number;
     subagentId?: string;
 }
 export type ToolCallPayload = ToolCallStartedPayload | ToolCallCompletedPayload;

package/dist/agent/types/message-types.d.ts

@@ -54,6 +54,8 @@ export interface ToolResultChunk {
     sizeLabel?: string;
     lineCount?: number;
     display?: string;
+    batchIndex?: number;
+    batchSize?: number;
     metadata?: Record<string, unknown>;
 }
 export interface ToolDiffChunk {

package/dist/cli/commands/interactive/tool-lane-format.d.ts

@@ -11,4 +11,5 @@ export declare const GROUP_THRESHOLD_DISPATCH = 2;
 export declare const GROUP_THRESHOLD_LEAF = 3;
 export declare function inProgressVerb(toolName: string): string;
 export declare function formatOutcome(chunk: ToolResultChunk, homeDir?: string, maxPreview?: number, toolName?: string): string;
+export declare function batchBadge(chunk: ToolResultChunk | undefined): string;
 export declare function formatToolResultLine(chunk: ToolResultChunk, toolPrefix?: string, homeDir?: string, toolName?: string): string;