agent-afk 5.1.0 → 5.3.0

package/dist/agent/mcp/naming.d.ts

@@ -0,0 +1,20 @@
+export declare function sanitizeNameSegment(input: string): string;
+export declare function buildMcpToolName(serverName: string, toolName: string): string;
+export declare function isMcpToolName(name: string): boolean;
+export interface McpNameRegistry {
+    tools: Map<string, {
+        serverName: string;
+        originalToolName: string;
+    }>;
+    conflicts: Array<{
+        wireName: string;
+        pairs: Array<{
+            serverName: string;
+            originalToolName: string;
+        }>;
+    }>;
+}
+export declare function buildMcpNameRegistry(entries: Iterable<{
+    serverName: string;
+    toolNames: string[];
+}>): McpNameRegistry;

package/dist/agent/mcp/oauth.d.ts

@@ -0,0 +1,33 @@
+import type { OAuthClientProvider, OAuthDiscoveryState } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { OAuthClientInformationMixed, OAuthTokens, OAuthClientMetadata } from '@modelcontextprotocol/sdk/shared/auth.js';
+export interface KeychainBackend {
+    read(): string | undefined;
+    write(blob: string): void;
+}
+export interface OauthPendingEntry {
+    status: 'oauth_pending';
+    authorizationUrl: string;
+    timestamp: number;
+}
+export declare function readOauthPending(): Record<string, OauthPendingEntry>;
+export declare function clearOauthPending(serverName: string): void;
+export declare class KeychainOAuthProvider implements OAuthClientProvider {
+    private readonly serverName;
+    private readonly backend;
+    constructor(serverName: string, backend?: KeychainBackend);
+    get redirectUrl(): string;
+    get clientMetadata(): OAuthClientMetadata;
+    clientInformation(): OAuthClientInformationMixed | undefined;
+    saveClientInformation(info: OAuthClientInformationMixed): void;
+    tokens(): OAuthTokens | undefined;
+    saveTokens(tokens: OAuthTokens): void;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    state(): string;
+    saveDiscoveryState(state: OAuthDiscoveryState): void;
+    discoveryState(): OAuthDiscoveryState | undefined;
+    invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery'): void;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    private _readSlot;
+    private _updateSlot;
+}

package/dist/agent/mcp/transport.d.ts

@@ -0,0 +1,16 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { McpServerConfig } from './types.js';
+export declare function expandHeaders(headers: Record<string, string> | undefined, source?: NodeJS.ProcessEnv): {
+    headers: Record<string, string>;
+    missing: string[];
+};
+export interface CreateTransportResult {
+    transport: Transport;
+    isSSE: boolean;
+}
+export declare function createTransport(serverName: string, config: McpServerConfig, oauthProvider?: OAuthClientProvider): CreateTransportResult;
+export declare function createTransportWithFallbackHint(serverName: string, config: McpServerConfig, oauthProvider?: OAuthClientProvider): {
+    primary: CreateTransportResult;
+    fallback: () => CreateTransportResult;
+};

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

@@ -0,0 +1,22 @@
+export type McpTransportType = 'stdio' | 'streamable-http' | 'sse';
+export interface McpServerConfig {
+    type?: McpTransportType;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    oauth?: boolean;
+    disabled?: boolean;
+    alwaysLoad?: boolean;
+    timeout?: number;
+}
+export type McpClientStatus = 'connecting' | 'connected' | 'error' | 'disabled' | 'oauth_pending';
+export interface McpClientState {
+    serverName: string;
+    config: McpServerConfig;
+    status: McpClientStatus;
+    error?: string;
+    toolCount: number;
+    lastListedAt?: number;
+}

package/dist/agent/memory/index.d.ts

@@ -0,0 +1,5 @@
+export { MemoryStore, estimateTokens } from './memory-store.js';
+export { loadHotMemory, injectHotMemory } from './memory-loader.js';
+export { createMemorySessionEndHook } from './memory-hooks.js';
+export { memorySearchTool, memoryUpdateTool, procedureWriteTool, memoryToolSchemas, MEMORY_TOOL_NAMES, createMemoryHandlers, } from './memory-tools.js';
+export type { Fact, NewFact, FactCategory, SessionRecord, NewSession, SessionOutcome, Procedure, SearchOpts, MemorySearchResult, MemoryUpdateAction, MemoryUpdateTarget, WALEntry, } from './types.js';

package/dist/agent/memory/memory-evidence.d.ts

@@ -0,0 +1,9 @@
+import type { FactCategory, FactVerification } from './types.js';
+export declare const CODEBASE_FACT_CATEGORIES: ReadonlySet<FactCategory>;
+export declare const UNVERIFIED_TAG = "[unverified]";
+export declare function isCodebaseFactCategory(category: FactCategory): boolean;
+export declare function evidenceGateEnabled(): boolean;
+export declare function requiresEvidence(category: FactCategory): boolean;
+export declare function normalizeEvidence(evidence: string | null | undefined): string | null;
+export declare function verificationStatus(category: FactCategory, evidence: string | null | undefined): FactVerification;
+export declare function applyUnverifiedTag(content: string, status: FactVerification): string;

package/dist/agent/memory/memory-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { HookHandler } from '../hooks.js';
+import { MemoryStore } from './memory-store.js';
+export declare function createMemorySessionEndHook(store: MemoryStore, surface?: string): HookHandler;

package/dist/agent/memory/memory-loader.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from '../types/config-types.js';
+export declare function loadHotMemory(): string | null;
+export declare function injectHotMemory(config: AgentConfig): AgentConfig;

package/dist/agent/memory/memory-store.d.ts

@@ -0,0 +1,36 @@
+import type { Fact, NewFact, SearchOpts, MemorySearchResult, SessionRecord, NewSession, Procedure, SessionOutcome } from './types.js';
+export declare const HOT_SOFT_WARN_RATIO = 0.8;
+export declare function estimateTokens(text: string): number;
+export interface HotUsage {
+    chars: number;
+    tokens: number;
+    maxTokens: number;
+    pct: number;
+    truncated: boolean;
+}
+export declare class MemoryStore {
+    private readonly dir;
+    private readonly db;
+    constructor(memoryDir?: string);
+    private enableWalMode;
+    loadHot(): string | null;
+    saveHot(content: string): HotUsage;
+    hotUsage(): HotUsage;
+    private computeHotUsage;
+    storeFact(fact: NewFact): number;
+    supersedeFact(factId: number, newContent: string, category?: string, evidence?: string | null): number;
+    removeFact(factId: number): boolean;
+    getFact(factId: number): Fact | null;
+    searchFacts(query: string, opts?: SearchOpts): Fact[];
+    startSession(session: NewSession): void;
+    endSession(sessionId: string, summary: string, outcome: SessionOutcome, tokenCount?: number, costUsd?: number): void;
+    getSession(sessionId: string): SessionRecord | null;
+    recentSessions(limit?: number): SessionRecord[];
+    writeProcedure(name: string, content: string, sessionId?: string): void;
+    loadProcedure(name: string): Procedure | null;
+    searchProcedures(query: string): Procedure[];
+    search(query: string, opts?: SearchOpts): MemorySearchResult[];
+    replayWAL(): number;
+    close(): void;
+    private appendWAL;
+}

package/dist/agent/memory/memory-tool-renderers.d.ts

@@ -0,0 +1,3 @@
+export declare function formatMemorySearchDisplay(rawContent: string): string | null;
+export declare function formatMemoryUpdateDisplay(rawContent: string): string | null;
+export declare function formatProcedureWriteDisplay(rawContent: string): string | null;

package/dist/agent/memory/memory-tools.d.ts

@@ -0,0 +1,8 @@
+import type { AnthropicToolDef, ToolHandler } from '../tools/types.js';
+import { MemoryStore } from './memory-store.js';
+export declare const memorySearchTool: AnthropicToolDef;
+export declare const memoryUpdateTool: AnthropicToolDef;
+export declare const procedureWriteTool: AnthropicToolDef;
+export declare const memoryToolSchemas: readonly AnthropicToolDef[];
+export declare const MEMORY_TOOL_NAMES: string[];
+export declare function createMemoryHandlers(store: MemoryStore, sessionId?: string, surface?: string): Map<string, ToolHandler>;

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

@@ -0,0 +1,70 @@
+import type { TraceActor } from '../session/session-identity.js';
+export type FactCategory = 'preference' | 'convention' | 'decision' | 'learning';
+export type SessionOutcome = 'completed' | 'failed' | 'abandoned';
+export type MemoryUpdateAction = 'set' | 'supersede' | 'remove';
+export type MemoryUpdateTarget = 'hot' | 'fact';
+export type FactVerification = 'verified' | 'unverified' | 'not-applicable';
+export interface Fact {
+    id: number;
+    session_id: string | null;
+    created_at: string;
+    category: FactCategory;
+    content: string;
+    source_surface: string;
+    superseded_by: number | null;
+    confidence: number;
+    access_count: number;
+    last_accessed: string | null;
+    evidence: string | null;
+}
+export interface NewFact {
+    session_id?: string;
+    category: FactCategory;
+    content: string;
+    source_surface: string;
+    evidence?: string | null;
+}
+export interface SessionRecord {
+    session_id: string;
+    surface: string;
+    started_at: string;
+    ended_at: string | null;
+    summary: string | null;
+    tools_used: string;
+    outcome: SessionOutcome | null;
+    token_count: number | null;
+    cost_usd: number | null;
+    actor?: TraceActor | null;
+}
+export interface NewSession {
+    session_id: string;
+    surface: string;
+    actor?: TraceActor;
+}
+export interface Procedure {
+    name: string;
+    content: string;
+    created: string;
+    source_session: string | null;
+    access_count: number;
+}
+export interface SearchOpts {
+    category?: FactCategory;
+    since?: string;
+    limit?: number;
+}
+export interface MemorySearchResult {
+    type: 'fact' | 'procedure';
+    content: string;
+    category?: FactCategory;
+    created_at: string;
+    source_session?: string | null;
+    confidence: number;
+    evidence?: string | null;
+    verification?: FactVerification;
+}
+export interface WALEntry {
+    type: 'fact' | 'session_start' | 'session_end' | 'supersede';
+    timestamp: string;
+    data: Record<string, unknown>;
+}

package/dist/agent/model-capabilities.d.ts

@@ -0,0 +1 @@
+export declare function supportsVision(model: string | undefined): boolean;

package/dist/agent/model-limits.d.ts

@@ -0,0 +1,5 @@
+import type { ClaudeModel } from './types.js';
+export declare const MODEL_MAX_OUTPUT_TOKENS: Record<string, number>;
+export declare function maxOutputTokensFor(model: ClaudeModel | string): number;
+export declare const MODEL_CONTEXT_LIMITS: Record<string, number>;
+export declare function contextLimitFor(model: ClaudeModel | string): number;

package/dist/agent/output-extractor.d.ts

@@ -0,0 +1 @@
+export declare function extractStructuredOutput(content: string): unknown;

package/dist/agent/permission-policy.d.ts

@@ -0,0 +1,2 @@
+import type { PermissionMode } from './types/sdk-types.js';
+export declare function pathContainmentBypassed(mode: PermissionMode | string | undefined): boolean;

package/dist/agent/permissions-store.d.ts

@@ -0,0 +1,28 @@
+export type GrantMode = 'read' | 'write';
+export type GrantDecision = 'allow' | 'deny';
+export type GrantSource = 'elicit:repl' | 'elicit:telegram' | 'elicit:unknown' | 'manual';
+export interface PermissionGrant {
+    id: string;
+    path: string;
+    mode: GrantMode;
+    decision: GrantDecision;
+    grantedAt: string;
+    source: GrantSource;
+    reason?: string;
+    expiresAt?: string;
+}
+export interface PermissionsFile {
+    version: 1;
+    grants: PermissionGrant[];
+}
+export declare function generateUlid(now?: number): string;
+export declare function loadPermissionsFile(filePath?: string): PermissionsFile;
+export declare function appendGrant(body: Omit<PermissionGrant, 'id' | 'grantedAt'> & {
+    grantedAt?: string;
+}, filePath?: string): PermissionGrant;
+export declare function revokeGrantById(id: string, filePath?: string): boolean;
+export declare function allowedPathsForMode(mode: GrantMode, filePath?: string): string[];
+export declare function seedPersistedGrants(grantManager: {
+    addReadRoot(absPath: string, source: 'slash' | 'tool'): void;
+    addWriteRoot(absPath: string, source: 'slash' | 'tool'): void;
+}, filePath?: string): void;

package/dist/agent/permissions.d.ts

@@ -0,0 +1,28 @@
+import type { CanUseTool } from './types/sdk-types.js';
+export type ToolPermissionMode = 'allow' | 'deny' | 'ask';
+export interface ToolPermission {
+    tool: string;
+    mode: ToolPermissionMode;
+    reason?: string;
+}
+export interface ToolPermissionRules {
+    defaultMode?: ToolPermissionMode;
+    tools?: Record<string, ToolPermissionMode | {
+        mode: ToolPermissionMode;
+        reason?: string;
+    }>;
+    list?: ToolPermission[];
+}
+export interface CanUseToolContext {
+    toolName: string;
+    input: Record<string, unknown>;
+}
+export interface PermissionDecision {
+    behavior: 'allow' | 'deny';
+    reason?: string;
+}
+export declare function createCanUseToolHook(options: {
+    rules: ToolPermissionRules;
+    onAsk?: (ctx: CanUseToolContext) => Promise<PermissionDecision>;
+    onDecision?: (ctx: CanUseToolContext, decision: PermissionDecision) => void;
+}): CanUseTool;

package/dist/agent/plan-mode-exit-prompt.d.ts

@@ -0,0 +1 @@
+export declare function buildPlanExitPrompt(plansDir: string): string;

package/dist/agent/plan-mode-gate.d.ts

@@ -0,0 +1,3 @@
+import type { HookContext, HookDecision } from './hooks.js';
+import type { PermissionMode } from './types/sdk-types.js';
+export declare function createPlanModeGate(getMode: () => PermissionMode): (context: HookContext) => HookDecision;

package/dist/agent/plugins/git-test-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function subcommandOf(args: readonly string[]): string | undefined;
+export declare function hasFlagPair(args: readonly string[], value: string): boolean;

package/dist/agent/plugins/git.d.ts

@@ -0,0 +1,21 @@
+export interface GitRunner {
+    (args: readonly string[], cwd?: string, env?: NodeJS.ProcessEnv): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export interface GitOptions {
+    runner?: GitRunner;
+    env?: NodeJS.ProcessEnv;
+}
+export interface CheckoutOptions extends GitOptions {
+    force?: boolean;
+}
+export declare function withHardening(args: readonly string[]): string[];
+export declare function clone(url: string, dest: string, opts?: GitOptions): Promise<void>;
+export declare function fetch(repo: string, opts?: GitOptions): Promise<void>;
+export declare function listTags(repo: string, opts?: GitOptions): Promise<string[]>;
+export declare function checkout(repo: string, ref: string, opts?: CheckoutOptions): Promise<void>;
+export declare function getCommitSha(repo: string, opts?: GitOptions): Promise<string>;
+export declare function tryRevParse(repo: string, rev: string, opts?: GitOptions): Promise<string | null>;
+export declare function getDefaultBranch(repo: string, opts?: GitOptions): Promise<string>;

package/dist/agent/plugins/index-store.d.ts

@@ -0,0 +1,32 @@
+export type SourceType = 'git' | 'github' | 'local' | 'marketplace';
+export interface PluginIndexEntry {
+    source: string;
+    sourceType: SourceType;
+    ref: string | null;
+    commit: string | null;
+    enabled: boolean;
+    installedAt: string;
+    updatedAt: string;
+    manifestName?: string;
+    marketplace?: string;
+}
+export interface MarketplaceIndexEntry {
+    source: string;
+    sourceType: 'git' | 'github' | 'local';
+    ref: string | null;
+    commit: string | null;
+    installedAt: string;
+    updatedAt: string;
+}
+export interface PluginIndex {
+    version: 2;
+    plugins: Record<string, PluginIndexEntry>;
+    marketplaces: Record<string, MarketplaceIndexEntry>;
+}
+export declare function readIndex(path?: string): PluginIndex;
+export declare function writeIndex(index: PluginIndex, path?: string): void;
+export declare function upsertPlugin(name: string, entry: PluginIndexEntry, path?: string): PluginIndex;
+export declare function removePlugin(name: string, path?: string): PluginIndex;
+export declare function setEnabled(name: string, enabled: boolean, path?: string): PluginIndex;
+export declare function upsertMarketplace(name: string, entry: MarketplaceIndexEntry, path?: string): PluginIndex;
+export declare function removeMarketplace(name: string, path?: string): PluginIndex;

package/dist/agent/plugins/install.d.ts

@@ -0,0 +1,23 @@
+import * as git from './git.js';
+import { type PluginIndexEntry } from './index-store.js';
+export interface InstallOptions {
+    name?: string;
+    ref?: string;
+    force?: boolean;
+}
+export interface InstallResult {
+    name: string;
+    dir: string;
+    entry: PluginIndexEntry;
+}
+export interface InstallDeps {
+    pluginsDir?: string;
+    indexPath?: string;
+    gitRunner?: git.GitRunner;
+    now?: () => Date;
+    confirm?: boolean;
+    confirmDelayMs?: number;
+}
+export declare function installPlugin(source: string, options?: InstallOptions, deps?: InstallDeps): Promise<InstallResult>;
+export declare function assertSafePluginName(name: string): void;
+export declare function assertWithinPluginsDir(dest: string, parentDir: string): void;

package/dist/agent/plugins/inventory.d.ts

@@ -0,0 +1,16 @@
+import { type PluginIndexEntry } from './index-store.js';
+export interface InstalledPlugin {
+    name: string;
+    version: string | null;
+    ref: string | null;
+    commit: string | null;
+    source: string | null;
+    sourceType: PluginIndexEntry['sourceType'] | null;
+    dir: string;
+}
+export interface ListInstalledPluginsDeps {
+    roots?: string[];
+    indexPath?: string;
+}
+export declare function listInstalledPlugins(deps?: ListInstalledPluginsDeps): InstalledPlugin[];
+export declare function formatPluginVersion(p: InstalledPlugin): string;

package/dist/agent/plugins/load-entrypoints.d.ts

@@ -0,0 +1,7 @@
+import type { SdkPluginConfig } from '../types/sdk-types.js';
+export declare function _resetLoadedEntrypoints(): void;
+export type LoadEntrypointsOptions = {
+    importer?: (specifier: string) => Promise<unknown>;
+    onError?: (plugin: SdkPluginConfig, error: unknown) => void;
+};
+export declare function loadPluginEntrypoints(plugins: readonly SdkPluginConfig[], opts?: LoadEntrypointsOptions): Promise<void>;

package/dist/agent/plugins/plugin-manifest.d.ts

@@ -0,0 +1,5 @@
+export interface PluginManifestFields {
+    name: string | null;
+    version: string | null;
+}
+export declare function readPluginManifest(dir: string): PluginManifestFields;

package/dist/agent/plugins/remove.d.ts

@@ -0,0 +1,10 @@
+export interface RemoveOptions {
+    pluginsDir?: string;
+    indexPath?: string;
+}
+export interface RemoveResult {
+    name: string;
+    removedDir: boolean;
+    removedIndexEntry: boolean;
+}
+export declare function removePlugin(name: string, opts?: RemoveOptions): RemoveResult;

package/dist/agent/plugins/source.d.ts

@@ -0,0 +1,23 @@
+export interface GitSource {
+    type: 'git';
+    url: string;
+}
+export interface GitHubSource {
+    type: 'github';
+    owner: string;
+    repo: string;
+    url: string;
+}
+export interface LocalSource {
+    type: 'local';
+    path: string;
+}
+export interface MarketplaceRefSource {
+    type: 'marketplace-ref';
+    marketplace: string;
+    plugin: string;
+}
+export type ParsedSource = GitSource | GitHubSource | LocalSource | MarketplaceRefSource;
+export declare function expandHome(input: string): string;
+export declare function assertHttpsUrl(url: string): void;
+export declare function parseSource(input: string): ParsedSource;

package/dist/agent/plugins/tool-injector.d.ts

@@ -0,0 +1,18 @@
+import type { AnthropicToolDef } from '../providers/anthropic-direct/types.js';
+import type { SdkPluginConfig } from '../types/sdk-types.js';
+export interface PluginSkillMetadata {
+    name?: string;
+    description?: string;
+    argumentHint?: string;
+    allowedTools?: string[];
+    context?: string;
+    readOnly?: boolean;
+    body?: string;
+    audience?: 'public' | 'internal';
+}
+export declare function normalizeToolToken(token: string, knownToolNames: ReadonlySet<string>): string | undefined;
+export declare function parseToolsField(inlineValue: string, remainingLines: string[]): string[];
+export declare function extractPluginSkills(pluginPath: string, knownToolNames?: ReadonlySet<string>): PluginSkillMetadata[];
+export declare function extractPluginTools(pluginPath: string, pluginName: string): AnthropicToolDef[];
+export declare function extractAllPluginTools(plugins: SdkPluginConfig[]): AnthropicToolDef[];
+export declare function extractPluginName(pluginPath: string): string;

package/dist/agent/plugins/update.d.ts

@@ -0,0 +1,33 @@
+import * as git from './git.js';
+export interface UpdateOptions {
+    ref?: string;
+}
+export interface UpdateDeps {
+    pluginsDir?: string;
+    indexPath?: string;
+    gitRunner?: git.GitRunner;
+    now?: () => Date;
+}
+export type UpdateOutcome = {
+    name: string;
+    status: 'updated';
+    fromRef: string | null;
+    toRef: string;
+    commit: string;
+    version: string | null;
+} | {
+    name: string;
+    status: 'up-to-date';
+    ref: string;
+    commit: string;
+    version: string | null;
+} | {
+    name: string;
+    status: 'skipped-local';
+} | {
+    name: string;
+    status: 'missing-dir';
+    dir: string;
+};
+export declare function updatePlugin(name: string, options?: UpdateOptions, deps?: UpdateDeps): Promise<UpdateOutcome>;
+export declare function updateAll(deps?: UpdateDeps): Promise<UpdateOutcome[]>;

package/dist/agent/plugins/versions.d.ts

@@ -0,0 +1 @@
+export declare function pickLatestSemverTag(tags: readonly string[]): string | null;

package/dist/agent/plugins-scanner.d.ts

@@ -0,0 +1,9 @@
+import type { SdkPluginConfig } from './types/sdk-types.js';
+export declare function _resetPluginScanCache(): void;
+export declare function scanLocalPlugins(dir?: string, opts?: {
+    trustAll?: boolean;
+}): SdkPluginConfig[];
+export declare function indexKeyForPath(root: string, leaf: string): {
+    layout: 'flat' | 'cache';
+    key: string;
+} | null;