agent-afk 5.291.0 → 5.292.0

package/dist/agent/provider.d.ts

@@ -1,6 +1,7 @@
 import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
 import type { AgentConfig } from './types/config-types.js';
 import type { ToolFailureClass } from './trace/types.js';
+import type { UsageLimitProvider } from '../utils/errors.js';
 export interface ProviderSessionInfo {
     sessionId: string;
     model?: string;
@@ -143,6 +144,8 @@ export type ProviderEvent = {
     accountId?: string;
     autoResume?: boolean;
     waitDeadline?: Date;
+    provider?: UsageLimitProvider;
+    plan?: string;
 } | {
     type: 'resumed';
     hotSwapped: boolean;

package/dist/agent/providers/anthropic-direct/usage-limit.error.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderEvent } from '../../provider.js';
+import type { UsageLimitInfo } from '../../../utils/errors.js';
+export declare function anthropicSubscriptionLimit(resetsAt?: Date): UsageLimitInfo;
+export declare function anthropicLimitErrorEvent(event: ProviderEvent, resetsAt?: Date): ProviderEvent;
+export declare function anthropicCreditErrorEvent(event: ProviderEvent): ProviderEvent;

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

@@ -11,7 +11,10 @@ export interface OpenAIFunctionTool {
     };
 }
 export declare function toolDefsToOpenAIFunctions(defs: readonly AnthropicToolDef[]): OpenAIFunctionTool[];
-export declare function accumulatedToolCallsToToolCalls(calls: readonly AccumulatedToolCall[], signal: AbortSignal): {
+export declare function toolsRequiringArgs(defs: readonly AnthropicToolDef[]): Set<string>;
+export declare function requiredArgToolsOf(dispatcher: unknown): Set<string> | undefined;
+export declare function noArgumentsReceivedMessage(name: string): string;
+export declare function accumulatedToolCallsToToolCalls(calls: readonly AccumulatedToolCall[], signal: AbortSignal, requiredArgTools?: ReadonlySet<string>): {
     calls: ToolCall[];
     parseErrors: Map<string, string>;
 };

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

@@ -0,0 +1,8 @@
+export declare const CHATGPT_USAGE_LIMIT_TYPE = "usage_limit_reached";
+export interface ChatGptUsageLimitInfo {
+    resetsAt?: Date;
+    plan?: string;
+    windowMinutes?: number;
+}
+export declare function classifyChatGptUsageLimit(err: unknown, now?: number): ChatGptUsageLimitInfo | null;
+export declare function isChatGptUsageLimitError(err: unknown): boolean;

package/dist/agent/providers/openai-compatible/responses-translate.d.ts

@@ -5,6 +5,8 @@ export interface ResponsesStreamEvent {
     delta?: string;
     output_index?: number;
     item_id?: string;
+    arguments?: string;
+    name?: string;
     item?: {
         type?: string;
         id?: string;

package/dist/agent/providers/shared/usage-limit-error.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderEvent } from '../../provider.js';
+import { UsageLimitError, type UsageLimitInfo } from '../../../utils/errors.js';
+export declare function toUsageLimitError(cause: unknown, info: UsageLimitInfo, now?: number): UsageLimitError;
+export declare function usageLimitErrorEvent(event: ProviderEvent, info: UsageLimitInfo): ProviderEvent;

package/dist/agent/tools/skill-executor/fork-dispatch.d.ts

@@ -5,11 +5,12 @@ import { type JournalParentHolder } from './fork-child-config.js';
 import type { SkillExecutorInternals } from './types.js';
 export declare function executeForkedRegistrySkill(internals: SkillExecutorInternals, skill: {
     name: string;
+    description?: string;
     context?: 'inline' | 'fork' | 'load';
     model?: string;
     readOnly?: boolean;
 }, args: string | undefined, call: ToolCall): Promise<ToolResult>;
-export declare function executePluginSkill(internals: SkillExecutorInternals, skillName: string, body: string, pluginPath: string, args: string | undefined, call: ToolCall, readOnly?: boolean, allowedTools?: string[], model?: string): Promise<ToolResult>;
+export declare function executePluginSkill(internals: SkillExecutorInternals, skillName: string, body: string, pluginPath: string, args: string | undefined, call: ToolCall, readOnly?: boolean, allowedTools?: string[], model?: string, description?: string): Promise<ToolResult>;
 export declare function runForkedSkillToResult(internals: SkillExecutorInternals, params: {
     manager: SubagentManager;
     childManager: SubagentManager | undefined;

package/dist/agent/tools/skill-executor/fork-identity.d.ts

@@ -0,0 +1,3 @@
+import type { SubagentProgressSink } from '../../types/session-types.js';
+import type { SkillIdentity } from '../../types/skill-identity.js';
+export declare function withSkillIdentity(sink: SubagentProgressSink | undefined, callId: string, identity: SkillIdentity): SubagentProgressSink | undefined;

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

@@ -7,6 +7,7 @@ import type { ProviderCommandInfo, ProviderCompactResult, ProviderContextUsage,
 import type { HookRegistry } from '../hooks.js';
 import type { MessageJournal } from '../journal/types.js';
 import type { ZodType } from 'zod';
+import type { UsageLimitProvider } from '../../utils/errors.js';
 export type SessionState = 'idle' | 'processing' | 'streaming' | 'compacting' | 'closed';
 export interface SessionIdentity {
     sessionId?: string;
@@ -85,6 +86,8 @@ export type OutputEvent = {
     accountId?: string;
     autoResume?: boolean;
     waitDeadline?: Date;
+    provider?: UsageLimitProvider;
+    plan?: string;
 } | {
     type: 'resumed';
     hotSwapped: boolean;
@@ -123,6 +126,7 @@ export interface ProgressEvent {
     durationMs: number;
 }
 export interface SubagentProgressMeta {
+    skillIdentity?: import('./skill-identity.js').SkillIdentity;
     subagentId: string;
     parentId?: string;
     agentType?: string;

package/dist/agent/types/skill-identity.d.ts

@@ -0,0 +1,5 @@
+export interface SkillIdentity {
+    name: string;
+    purpose?: string;
+    arguments?: string;
+}

package/dist/agent/usage/usage-formatter.d.ts

@@ -1,5 +1,6 @@
 import { type UsageRecord } from './usage-record.js';
 import { type BindingWindow } from './usage-budget.js';
+import type { UsageLimitInfo, UsageLimitProvider } from '../../utils/errors.js';
 export interface UsageWindowSummary {
     readonly utilization: number;
     readonly utilizationPct: number;
@@ -43,6 +44,9 @@ export declare function unknownProviderSummary(provider: string, account: string
 export declare function errorProviderSummary(provider: string, account: string, detail: string): ProviderUsageSummary;
 export declare function compactUsageEntries(records: readonly UsageRecord[], now?: number): CompactUsageEntry[];
 export declare function describeBindingWindow(provider: string, binding: BindingWindow, now?: number): string;
+export declare function usageLimitProviderName(provider: UsageLimitProvider | undefined): string;
+export declare function describeResetTime(resetsAt: Date, now?: number): string;
+export declare function describeUsageLimit(info: UsageLimitInfo, now?: number): string;
 export interface UsageRow {
     readonly label: string;
     readonly value: string;

package/dist/agent/usage/usage-limit-info.d.ts

@@ -0,0 +1,3 @@
+import { type UsageLimitInfo } from '../../utils/errors.js';
+export declare function usageLimitInfoOf(err: unknown, now?: number): UsageLimitInfo | null;
+export declare function normalizeUsageLimitError(err: unknown, now?: number): unknown;

package/dist/cli/_lib/skill-identity-format.d.ts

@@ -0,0 +1,11 @@
+import type { SkillIdentity } from '../../agent/types/skill-identity.js';
+export type { SkillIdentity } from '../../agent/types/skill-identity.js';
+export declare const SKILL_IDENTITY_BUDGETS: {
+    readonly name: 32;
+    readonly purpose: 96;
+    readonly arguments: 96;
+    readonly total: 240;
+};
+export declare function sanitizeSkillIdentity(input: SkillIdentity): SkillIdentity;
+export declare function formatSkillIdentity(input: SkillIdentity, width: number, activity?: string): string;
+export declare function skillIdentityBanner(identity: SkillIdentity | undefined, lines: string[], width: number): string;

package/dist/cli/_lib/skill-identity-state.d.ts

@@ -0,0 +1,11 @@
+import { type SkillIdentity } from './skill-identity-format.js';
+import type { CommitCoordinator } from './commit-coordinator.js';
+import type { TerminalCompositor } from '../terminal-compositor.js';
+import type { Writer } from '../slash/types.js';
+export declare class SkillIdentityState {
+    current: SkillIdentity | undefined;
+    private introduced;
+    constructor(identity?: SkillIdentity);
+    introduce(coordinator: CommitCoordinator, compositor: TerminalCompositor | null, out: Writer): Promise<void>;
+    clear(): void;
+}

package/dist/cli/_lib/stream-renderer-contexts.d.ts

@@ -26,6 +26,7 @@ export declare function makeOrchestratorCtx(args: {
     coordinator: CommitCoordinator;
     stageTracker?: StageTrackerState;
     activeSkillName?: string;
+    skillIdentity?: import('./skill-identity-format.js').SkillIdentity;
     lastProgressByTask: Map<string, ProgressEvent>;
     sources?: ReadonlyMap<string, SourceState>;
     childActivity?: ChildActivityTracker;

package/dist/cli/_lib/stream-renderer-lifecycle.d.ts

@@ -9,6 +9,7 @@ import type { StreamingMarkdownRenderer } from '../markdown-stream.js';
 import type { Writer } from '../slash/types.js';
 import type { ProgressEvent } from '../../agent/types.js';
 import { type TtfbTickCtx } from './stream-renderer-ttfb.js';
+import { type SkillIdentity } from './skill-identity-format.js';
 export interface LifecycleContext extends TtfbTickCtx {
     compositor: TerminalCompositor | null;
     overlayComposer: OverlayComposer | null;
@@ -28,6 +29,7 @@ export interface LifecycleContext extends TtfbTickCtx {
 export declare function registerOverlaySlots(overlayComposer: OverlayComposer, ctx: Readonly<Pick<LifecycleContext, 'stageTracker' | 'thinkingMode' | 'thinkingLane' | 'streamingMarkdownRef' | 'toolLane' | 'lastProgressByTask'>> & {
     sources?: ReadonlyMap<string, SourceState>;
     childActivity?: ChildActivityTracker;
+    getSkillIdentity?: () => SkillIdentity | undefined;
     getInterrupting: () => boolean;
     getSoftStopping: () => boolean;
 }): void;

package/dist/cli/_lib/stream-renderer-options.d.ts

@@ -4,6 +4,7 @@ import type { AutocompleteState } from '../input/autocomplete-state.js';
 import type { TerminalCompositor } from '../terminal-compositor.js';
 import type { PreviewDiffRef } from '../../agent/tools/hooks/edit-preview-hook.js';
 export interface StreamRendererOptions {
+    skillIdentity?: import('./skill-identity-format.js').SkillIdentity;
     out: Writer;
     thinkingMode?: 'off' | 'summary' | 'live' | 'digest';
     verbose?: boolean;

package/dist/cli/_lib/stream-renderer-orchestrator.d.ts

@@ -11,7 +11,9 @@ import type { OverlayComposer } from './overlay-composer.js';
 import type { ThoughtSummaryHold } from './thought-summary-hold.js';
 import { type StageTrackerState } from '../commands/interactive/loop-stage.js';
 export { emitPanel, finalizeOrchestrator, emitMarkdown, emitErrorBox, flushToolLaneToScrollback, } from './stream-renderer-orchestrator-emit.js';
+import { type SkillIdentity } from './skill-identity-format.js';
 export interface OrchestratorCtx {
+    skillIdentity?: SkillIdentity;
     out: Writer;
     isTTY: boolean;
     compositor: TerminalCompositor | null;

package/dist/cli/_lib/stream-renderer.d.ts

@@ -5,6 +5,7 @@ export type { StreamRendererOptions } from './stream-renderer-options.js';
 import type { StreamRendererOptions } from './stream-renderer-options.js';
 export declare class StreamRenderer {
     private readonly out;
+    private readonly skillIdentity;
     private readonly thinkingMode;
     private readonly isTTY;
     private readonly captureMode;

package/dist/cli/commands/interactive/peer-arrival-format.d.ts

@@ -0,0 +1,3 @@
+import type { PeerEnvelope } from '../../../agent/peer/envelope.js';
+export declare function safePeerSender(from: PeerEnvelope['from']): string;
+export declare function formatPeerArrival(e: Pick<PeerEnvelope, 'from' | 'body'>, width: number): string;

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

@@ -1,3 +1,4 @@
+import { type SkillIdentity } from '../../_lib/skill-identity-format.js';
 import type { ToolResultChunk } from '../../../agent/types/message-types.js';
 import { formatToolLine, formatToolResultLine } from './tool-lane-format.js';
 import type { DiffPayload } from '../../../utils/diff.js';
@@ -20,6 +21,7 @@ export declare class ToolLane {
     addStart(toolUseId: string, toolName: string, toolInput: string): void;
     addStartWithAgentContext(toolUseId: string, toolName: string, toolInput: string, agentContext: string | undefined, maxWidth?: number): void;
     mergeAgentLabel(parentToolUseId: string, label: string, maxWidth?: number): boolean;
+    setSkillIdentity(toolUseId: string, identity: SkillIdentity): void;
     setAgentContext(toolUseId: string, agentContext: string | undefined): void;
     setAgentResultSummary(toolUseId: string, summary: string): void;
     propagateChildFailure(failedId: string): void;

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

@@ -0,0 +1,2 @@
+import type { Entry } from './tool-lane-render.js';
+export declare function mergeAgentLabel(entries: ReadonlyMap<string, Entry>, parentToolUseId: string, label: string, maxWidth?: number): boolean;

package/dist/cli/commands/interactive/turn-handler.paused.d.ts

@@ -2,6 +2,7 @@ import type { OutputEvent } from '../../../agent/types.js';
 import type { AgentSession } from '../../../agent/session.js';
 import type { CompletionWriter } from './shared.js';
 import type { TerminalCompositor } from '../../terminal-compositor.js';
+export declare function pausedPickerHeader(event: PausedEvent, resetsAtStr: string | null): string[];
 export type PausedEvent = Extract<OutputEvent, {
     type: 'paused';
 }>;

package/dist/cli/errors/classifier.d.ts

@@ -1,4 +1,4 @@
-type ErrorKind = 'auth' | 'rate_limit' | 'overloaded' | 'budget_exceeded' | 'unsupported_config' | 'hook_blocked' | 'timeout' | 'network' | 'not_git_repo' | 'unknown';
+type ErrorKind = 'auth' | 'rate_limit' | 'usage_limit' | 'overloaded' | 'budget_exceeded' | 'unsupported_config' | 'hook_blocked' | 'timeout' | 'network' | 'not_git_repo' | 'unknown';
 export interface ClassifiedError {
     kind: ErrorKind;
     userMessage: string;

package/dist/cli/render/usage-limit-box.d.ts

@@ -1,7 +1,10 @@
+import type { UsageLimitProvider } from '../../utils/errors.js';
 export declare function usageLimitBox(opts: {
     resetsAt?: Date;
     reason: 'usage-limit' | 'credit-exhausted';
     accountId?: string;
     hotSwapped?: boolean;
     autoResume?: boolean;
+    provider?: UsageLimitProvider;
+    plan?: string;
 }): string;

package/dist/cli/slash/_lib/create-skill-renderer.d.ts

@@ -2,6 +2,7 @@ import { StreamRenderer } from '../../_lib/stream-renderer.js';
 import type { SlashContext, Writer } from '../types.js';
 export interface SkillRendererOpts {
     skillName: string;
+    skillIdentity?: import('../../_lib/skill-identity-format.js').SkillIdentity;
     verbose?: boolean;
     out?: Writer;
     onCancel?: () => void;