@anthropic-field/core 0.1.0

package/dist/src/telemetry/activity-detector.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Tracks user activity state to determine when memory monitoring should be active
+ */
+export class ActivityDetector {
+    lastActivityTime = Date.now();
+    idleThresholdMs;
+    constructor(idleThresholdMs = 30000) {
+        this.idleThresholdMs = idleThresholdMs;
+    }
+    /**
+     * Record user activity (called by CLI when user types, adds messages, etc.)
+     */
+    recordActivity() {
+        this.lastActivityTime = Date.now();
+    }
+    /**
+     * Check if user is currently active (activity within idle threshold)
+     */
+    isUserActive() {
+        const timeSinceActivity = Date.now() - this.lastActivityTime;
+        return timeSinceActivity < this.idleThresholdMs;
+    }
+    /**
+     * Get time since last activity in milliseconds
+     */
+    getTimeSinceLastActivity() {
+        return Date.now() - this.lastActivityTime;
+    }
+    /**
+     * Get last activity timestamp
+     */
+    getLastActivityTime() {
+        return this.lastActivityTime;
+    }
+}
+// Global activity detector instance (eagerly created with default threshold)
+const globalActivityDetector = new ActivityDetector();
+/**
+ * Get global activity detector instance
+ */
+export function getActivityDetector() {
+    return globalActivityDetector;
+}
+/**
+ * Record user activity (convenience function for CLI to call)
+ */
+export function recordUserActivity() {
+    globalActivityDetector.recordActivity();
+}
+/**
+ * Check if user is currently active (convenience function)
+ */
+export function isUserActive() {
+    return globalActivityDetector.isUserActive();
+}
+//# sourceMappingURL=activity-detector.js.map

package/dist/src/telemetry/activity-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-detector.js","sourceRoot":"","sources":["../../../src/telemetry/activity-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,OAAO,gBAAgB;IACnB,gBAAgB,GAAW,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,eAAe,CAAS;IAEzC,YAAY,kBAA0B,KAAK;QACzC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,YAAY;QACV,MAAM,iBAAiB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC7D,OAAO,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,wBAAwB;QACtB,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,mBAAmB;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;CACF;AAED,6EAA6E;AAC7E,MAAM,sBAAsB,GAAqB,IAAI,gBAAgB,EAAE,CAAC;AAExE;;GAEG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,sBAAsB,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAChC,sBAAsB,CAAC,cAAc,EAAE,CAAC;AAC1C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,sBAAsB,CAAC,YAAY,EAAE,CAAC;AAC/C,CAAC"}

package/dist/src/telemetry/activity-monitor.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Config } from '../config/config.js';
+import { ActivityType } from './activity-types.js';
+/**
+ * Activity event data structure
+ */
+export interface ActivityEvent {
+    type: ActivityType;
+    timestamp: number;
+    context?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Configuration for activity monitoring
+ */
+export interface ActivityMonitorConfig {
+    /** Enable/disable activity monitoring */
+    enabled: boolean;
+    /** Minimum interval between memory snapshots (ms) */
+    snapshotThrottleMs: number;
+    /** Maximum number of events to buffer */
+    maxEventBuffer: number;
+    /** Activity types that should trigger immediate memory snapshots */
+    triggerActivities: ActivityType[];
+}
+/**
+ * Activity listener callback function
+ */
+export type ActivityListener = (event: ActivityEvent) => void;
+/**
+ * Default configuration for activity monitoring
+ */
+export declare const DEFAULT_ACTIVITY_CONFIG: ActivityMonitorConfig;
+/**
+ * Activity monitor class that tracks user activity and triggers memory monitoring
+ */
+export declare class ActivityMonitor {
+    private listeners;
+    private eventBuffer;
+    private lastSnapshotTime;
+    private config;
+    private isActive;
+    private memoryMonitoringListener;
+    constructor(config?: ActivityMonitorConfig);
+    /**
+     * Start activity monitoring
+     */
+    start(coreConfig: Config): void;
+    /**
+     * Stop activity monitoring
+     */
+    stop(): void;
+    /**
+     * Add an activity listener
+     */
+    addListener(listener: ActivityListener): void;
+    /**
+     * Remove an activity listener
+     */
+    removeListener(listener: ActivityListener): void;
+    /**
+     * Record a user activity event
+     */
+    recordActivity(type: ActivityType, context?: string, metadata?: Record<string, unknown>): void;
+    /**
+     * Get recent activity events
+     */
+    getRecentActivity(limit?: number): ActivityEvent[];
+    /**
+     * Get activity statistics
+     */
+    getActivityStats(): {
+        totalEvents: number;
+        eventTypes: Record<ActivityType, number>;
+        timeRange: {
+            start: number;
+            end: number;
+        } | null;
+    };
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<ActivityMonitorConfig>): void;
+    /**
+     * Handle memory monitoring for activity events
+     */
+    private handleMemoryMonitoringActivity;
+    /**
+     * Check if monitoring is active
+     */
+    isMonitoringActive(): boolean;
+}
+/**
+ * Initialize global activity monitor
+ */
+export declare function initializeActivityMonitor(config?: ActivityMonitorConfig): ActivityMonitor;
+/**
+ * Get global activity monitor instance
+ */
+export declare function getActivityMonitor(): ActivityMonitor | null;
+/**
+ * Record a user activity on the global monitor (convenience function)
+ */
+export declare function recordGlobalActivity(type: ActivityType, context?: string, metadata?: Record<string, unknown>): void;
+/**
+ * Start global activity monitoring
+ */
+export declare function startGlobalActivityMonitoring(coreConfig: Config, activityConfig?: ActivityMonitorConfig): void;
+/**
+ * Stop global activity monitoring
+ */
+export declare function stopGlobalActivityMonitoring(): void;

package/dist/src/telemetry/activity-monitor.js

@@ -0,0 +1,209 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isPerformanceMonitoringActive } from './metrics.js';
+import { getMemoryMonitor } from './memory-monitor.js';
+import { ActivityType } from './activity-types.js';
+import { debugLogger } from '../utils/debugLogger.js';
+/**
+ * Default configuration for activity monitoring
+ */
+export const DEFAULT_ACTIVITY_CONFIG = {
+    enabled: true,
+    snapshotThrottleMs: 1000, // 1 second minimum between snapshots
+    maxEventBuffer: 100,
+    triggerActivities: [
+        ActivityType.USER_INPUT_START,
+        ActivityType.MESSAGE_ADDED,
+        ActivityType.TOOL_CALL_SCHEDULED,
+        ActivityType.STREAM_START,
+    ],
+};
+/**
+ * Activity monitor class that tracks user activity and triggers memory monitoring
+ */
+export class ActivityMonitor {
+    listeners = new Set();
+    eventBuffer = [];
+    lastSnapshotTime = 0;
+    config;
+    isActive = false;
+    memoryMonitoringListener = null;
+    constructor(config = DEFAULT_ACTIVITY_CONFIG) {
+        this.config = { ...config };
+    }
+    /**
+     * Start activity monitoring
+     */
+    start(coreConfig) {
+        if (!isPerformanceMonitoringActive() || this.isActive) {
+            return;
+        }
+        this.isActive = true;
+        // Register default memory monitoring listener
+        this.memoryMonitoringListener = (event) => {
+            this.handleMemoryMonitoringActivity(event, coreConfig);
+        };
+        this.addListener(this.memoryMonitoringListener);
+        // Record activity monitoring start
+        this.recordActivity(ActivityType.MANUAL_TRIGGER, 'activity_monitoring_start');
+    }
+    /**
+     * Stop activity monitoring
+     */
+    stop() {
+        if (!this.isActive) {
+            return;
+        }
+        this.isActive = false;
+        if (this.memoryMonitoringListener) {
+            this.removeListener(this.memoryMonitoringListener);
+            this.memoryMonitoringListener = null;
+        }
+        this.eventBuffer = [];
+    }
+    /**
+     * Add an activity listener
+     */
+    addListener(listener) {
+        this.listeners.add(listener);
+    }
+    /**
+     * Remove an activity listener
+     */
+    removeListener(listener) {
+        this.listeners.delete(listener);
+    }
+    /**
+     * Record a user activity event
+     */
+    recordActivity(type, context, metadata) {
+        if (!this.isActive || !this.config.enabled) {
+            return;
+        }
+        const event = {
+            type,
+            timestamp: Date.now(),
+            context,
+            metadata,
+        };
+        // Add to buffer
+        this.eventBuffer.push(event);
+        if (this.eventBuffer.length > this.config.maxEventBuffer) {
+            this.eventBuffer.shift(); // Remove oldest event
+        }
+        // Notify listeners
+        this.listeners.forEach((listener) => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                // Silently catch listener errors to avoid disrupting the application
+                debugLogger.debug('ActivityMonitor listener error:', error);
+            }
+        });
+    }
+    /**
+     * Get recent activity events
+     */
+    getRecentActivity(limit) {
+        const events = [...this.eventBuffer];
+        return limit ? events.slice(-limit) : events;
+    }
+    /**
+     * Get activity statistics
+     */
+    getActivityStats() {
+        const eventTypes = {};
+        let start = Number.MAX_SAFE_INTEGER;
+        let end = 0;
+        for (const event of this.eventBuffer) {
+            eventTypes[event.type] = (eventTypes[event.type] || 0) + 1;
+            start = Math.min(start, event.timestamp);
+            end = Math.max(end, event.timestamp);
+        }
+        return {
+            totalEvents: this.eventBuffer.length,
+            eventTypes,
+            timeRange: this.eventBuffer.length > 0 ? { start, end } : null,
+        };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    /**
+     * Handle memory monitoring for activity events
+     */
+    handleMemoryMonitoringActivity(event, config) {
+        // Check if this activity type should trigger memory monitoring
+        if (!this.config.triggerActivities.includes(event.type)) {
+            return;
+        }
+        // Throttle memory snapshots
+        const now = Date.now();
+        if (now - this.lastSnapshotTime < this.config.snapshotThrottleMs) {
+            return;
+        }
+        this.lastSnapshotTime = now;
+        // Take memory snapshot
+        const memoryMonitor = getMemoryMonitor();
+        if (memoryMonitor) {
+            const context = event.context
+                ? `activity_${event.type}_${event.context}`
+                : `activity_${event.type}`;
+            memoryMonitor.takeSnapshot(context, config);
+        }
+    }
+    /**
+     * Check if monitoring is active
+     */
+    isMonitoringActive() {
+        return this.isActive && this.config.enabled;
+    }
+}
+// Singleton instance for global activity monitoring
+let globalActivityMonitor = null;
+/**
+ * Initialize global activity monitor
+ */
+export function initializeActivityMonitor(config) {
+    if (!globalActivityMonitor) {
+        globalActivityMonitor = new ActivityMonitor(config);
+    }
+    return globalActivityMonitor;
+}
+/**
+ * Get global activity monitor instance
+ */
+export function getActivityMonitor() {
+    return globalActivityMonitor;
+}
+/**
+ * Record a user activity on the global monitor (convenience function)
+ */
+export function recordGlobalActivity(type, context, metadata) {
+    if (globalActivityMonitor) {
+        globalActivityMonitor.recordActivity(type, context, metadata);
+    }
+}
+/**
+ * Start global activity monitoring
+ */
+export function startGlobalActivityMonitoring(coreConfig, activityConfig) {
+    const monitor = initializeActivityMonitor(activityConfig);
+    monitor.start(coreConfig);
+}
+/**
+ * Stop global activity monitoring
+ */
+export function stopGlobalActivityMonitoring() {
+    if (globalActivityMonitor) {
+        globalActivityMonitor.stop();
+    }
+}
+//# sourceMappingURL=activity-monitor.js.map

package/dist/src/telemetry/activity-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-monitor.js","sourceRoot":"","sources":["../../../src/telemetry/activity-monitor.ts"],"names":[],"mappings":"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"}

package/dist/src/telemetry/activity-types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Types of user activities that can be tracked
+ */
+export declare enum ActivityType {
+    USER_INPUT_START = "user_input_start",
+    USER_INPUT_END = "user_input_end",
+    MESSAGE_ADDED = "message_added",
+    TOOL_CALL_SCHEDULED = "tool_call_scheduled",
+    TOOL_CALL_COMPLETED = "tool_call_completed",
+    STREAM_START = "stream_start",
+    STREAM_END = "stream_end",
+    HISTORY_UPDATED = "history_updated",
+    MANUAL_TRIGGER = "manual_trigger"
+}

package/dist/src/telemetry/activity-types.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Types of user activities that can be tracked
+ */
+export var ActivityType;
+(function (ActivityType) {
+    ActivityType["USER_INPUT_START"] = "user_input_start";
+    ActivityType["USER_INPUT_END"] = "user_input_end";
+    ActivityType["MESSAGE_ADDED"] = "message_added";
+    ActivityType["TOOL_CALL_SCHEDULED"] = "tool_call_scheduled";
+    ActivityType["TOOL_CALL_COMPLETED"] = "tool_call_completed";
+    ActivityType["STREAM_START"] = "stream_start";
+    ActivityType["STREAM_END"] = "stream_end";
+    ActivityType["HISTORY_UPDATED"] = "history_updated";
+    ActivityType["MANUAL_TRIGGER"] = "manual_trigger";
+})(ActivityType || (ActivityType = {}));
+//# sourceMappingURL=activity-types.js.map

package/dist/src/telemetry/activity-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-types.js","sourceRoot":"","sources":["../../../src/telemetry/activity-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,CAAN,IAAY,YAUX;AAVD,WAAY,YAAY;IACtB,qDAAqC,CAAA;IACrC,iDAAiC,CAAA;IACjC,+CAA+B,CAAA;IAC/B,2DAA2C,CAAA;IAC3C,2DAA2C,CAAA;IAC3C,6CAA6B,CAAA;IAC7B,yCAAyB,CAAA;IACzB,mDAAmC,CAAA;IACnC,iDAAiC,CAAA;AACnC,CAAC,EAVW,YAAY,KAAZ,YAAY,QAUvB"}

package/dist/src/telemetry/clearcut-logger/clearcut-logger.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import type { StartSessionEvent, UserPromptEvent, ToolCallEvent, ApiRequestEvent, ApiResponseEvent, ApiErrorEvent, LoopDetectedEvent, NextSpeakerCheckEvent, SlashCommandEvent, MalformedJsonResponseEvent, IdeConnectionEvent, ConversationFinishedEvent, ChatCompressionEvent, FileOperationEvent, InvalidChunkEvent, ContentRetryEvent, ContentRetryFailureEvent, ExtensionInstallEvent, ToolOutputTruncatedEvent, ExtensionUninstallEvent, ModelRoutingEvent, ExtensionEnableEvent, ModelSlashCommandEvent, ExtensionDisableEvent, EditStrategyEvent, EditCorrectionEvent, AgentStartEvent, AgentFinishEvent, RecoveryAttemptEvent, WebFetchFallbackAttemptEvent, ExtensionUpdateEvent, LlmLoopCheckEvent, HookCallEvent, ApprovalModeSwitchEvent, ApprovalModeDurationEvent } from '../types.js';
+import { EventMetadataKey } from './event-metadata-key.js';
+import type { Config } from '../../config/config.js';
+export declare enum EventNames {
+    START_SESSION = "start_session",
+    NEW_PROMPT = "new_prompt",
+    TOOL_CALL = "tool_call",
+    FILE_OPERATION = "file_operation",
+    API_REQUEST = "api_request",
+    API_RESPONSE = "api_response",
+    API_ERROR = "api_error",
+    END_SESSION = "end_session",
+    FLASH_FALLBACK = "flash_fallback",
+    RIPGREP_FALLBACK = "ripgrep_fallback",
+    LOOP_DETECTED = "loop_detected",
+    LOOP_DETECTION_DISABLED = "loop_detection_disabled",
+    NEXT_SPEAKER_CHECK = "next_speaker_check",
+    SLASH_COMMAND = "slash_command",
+    MALFORMED_JSON_RESPONSE = "malformed_json_response",
+    IDE_CONNECTION = "ide_connection",
+    KITTY_SEQUENCE_OVERFLOW = "kitty_sequence_overflow",
+    CHAT_COMPRESSION = "chat_compression",
+    CONVERSATION_FINISHED = "conversation_finished",
+    INVALID_CHUNK = "invalid_chunk",
+    CONTENT_RETRY = "content_retry",
+    CONTENT_RETRY_FAILURE = "content_retry_failure",
+    EXTENSION_ENABLE = "extension_enable",
+    EXTENSION_DISABLE = "extension_disable",
+    EXTENSION_INSTALL = "extension_install",
+    EXTENSION_UNINSTALL = "extension_uninstall",
+    EXTENSION_UPDATE = "extension_update",
+    TOOL_OUTPUT_TRUNCATED = "tool_output_truncated",
+    MODEL_ROUTING = "model_routing",
+    MODEL_SLASH_COMMAND = "model_slash_command",
+    EDIT_STRATEGY = "edit_strategy",
+    EDIT_CORRECTION = "edit_correction",
+    AGENT_START = "agent_start",
+    AGENT_FINISH = "agent_finish",
+    RECOVERY_ATTEMPT = "recovery_attempt",
+    WEB_FETCH_FALLBACK_ATTEMPT = "web_fetch_fallback_attempt",
+    LLM_LOOP_CHECK = "llm_loop_check",
+    HOOK_CALL = "hook_call",
+    APPROVAL_MODE_SWITCH = "approval_mode_switch",
+    APPROVAL_MODE_DURATION = "approval_mode_duration"
+}
+export interface LogResponse {
+    nextRequestWaitMs?: number;
+}
+export interface LogEventEntry {
+    event_time_ms: number;
+    source_extension_json: string;
+    exp?: {
+        gws_experiment: number[];
+    };
+}
+export interface EventValue {
+    gemini_cli_key: EventMetadataKey;
+    value: string;
+}
+export interface LogEvent {
+    console_type: 'GEMINI_CLI';
+    application: number;
+    event_name: string;
+    event_metadata: EventValue[][];
+    client_email?: string;
+    client_install_id?: string;
+}
+export interface LogRequest {
+    log_source_name: 'CONCORD';
+    request_time_ms: number;
+    log_event: LogEventEntry[][];
+}
+declare function refreshGpuInfo(): Promise<void>;
+export declare class ClearcutLogger {
+    private static instance;
+    private config?;
+    private sessionData;
+    private promptId;
+    private readonly installationManager;
+    private readonly userAccountManager;
+    private readonly hashedGHRepositoryName?;
+    /**
+     * Queue of pending events that need to be flushed to the server.  New events
+     * are added to this queue and then flushed on demand (via `flushToClearcut`)
+     */
+    private readonly events;
+    /**
+     * The last time that the events were successfully flushed to the server.
+     */
+    private lastFlushTime;
+    /**
+     * the value is true when there is a pending flush happening. This prevents
+     * concurrent flush operations.
+     */
+    private flushing;
+    /**
+     * This value is true when a flush was requested during an ongoing flush.
+     */
+    private pendingFlush;
+    private constructor();
+    static getInstance(config?: Config): ClearcutLogger | undefined;
+    /** For testing purposes only. */
+    static clearInstance(): void;
+    enqueueHelper(event: LogEvent, experimentIds?: number[]): void;
+    enqueueLogEvent(event: LogEvent): void;
+    enqueueLogEventAfterExperimentsLoadAsync(event: LogEvent): Promise<void>;
+    createBasicLogEvent(eventName: EventNames, data?: EventValue[]): LogEvent;
+    createLogEvent(eventName: EventNames, data?: EventValue[]): LogEvent;
+    flushIfNeeded(): void;
+    flushToClearcut(): Promise<LogResponse>;
+    logStartSessionEvent(event: StartSessionEvent): Promise<void>;
+    logNewPromptEvent(event: UserPromptEvent): void;
+    logToolCallEvent(event: ToolCallEvent): void;
+    logFileOperationEvent(event: FileOperationEvent): void;
+    logApiRequestEvent(event: ApiRequestEvent): void;
+    logApiResponseEvent(event: ApiResponseEvent): void;
+    logApiErrorEvent(event: ApiErrorEvent): void;
+    logChatCompressionEvent(event: ChatCompressionEvent): void;
+    logFlashFallbackEvent(): void;
+    logRipgrepFallbackEvent(): void;
+    logLoopDetectedEvent(event: LoopDetectedEvent): void;
+    logLoopDetectionDisabledEvent(): void;
+    logNextSpeakerCheck(event: NextSpeakerCheckEvent): void;
+    logSlashCommandEvent(event: SlashCommandEvent): void;
+    logMalformedJsonResponseEvent(event: MalformedJsonResponseEvent): void;
+    logIdeConnectionEvent(event: IdeConnectionEvent): void;
+    logConversationFinishedEvent(event: ConversationFinishedEvent): void;
+    logEndSessionEvent(): void;
+    logInvalidChunkEvent(event: InvalidChunkEvent): void;
+    logContentRetryEvent(event: ContentRetryEvent): void;
+    logContentRetryFailureEvent(event: ContentRetryFailureEvent): void;
+    logExtensionInstallEvent(event: ExtensionInstallEvent): Promise<void>;
+    logExtensionUninstallEvent(event: ExtensionUninstallEvent): Promise<void>;
+    logExtensionUpdateEvent(event: ExtensionUpdateEvent): Promise<void>;
+    logToolOutputTruncatedEvent(event: ToolOutputTruncatedEvent): void;
+    logModelRoutingEvent(event: ModelRoutingEvent): void;
+    logExtensionEnableEvent(event: ExtensionEnableEvent): Promise<void>;
+    logModelSlashCommandEvent(event: ModelSlashCommandEvent): void;
+    logExtensionDisableEvent(event: ExtensionDisableEvent): Promise<void>;
+    logEditStrategyEvent(event: EditStrategyEvent): void;
+    logEditCorrectionEvent(event: EditCorrectionEvent): void;
+    logAgentStartEvent(event: AgentStartEvent): void;
+    logAgentFinishEvent(event: AgentFinishEvent): void;
+    logRecoveryAttemptEvent(event: RecoveryAttemptEvent): void;
+    logWebFetchFallbackAttemptEvent(event: WebFetchFallbackAttemptEvent): void;
+    logLlmLoopCheckEvent(event: LlmLoopCheckEvent): void;
+    logHookCallEvent(event: HookCallEvent): void;
+    logApprovalModeSwitchEvent(event: ApprovalModeSwitchEvent): void;
+    logApprovalModeDurationEvent(event: ApprovalModeDurationEvent): void;
+    /**
+     * Adds default fields to data, and returns a new data array.  This fields
+     * should exist on all log events.
+     */
+    addDefaultFields(data: EventValue[], totalAccounts: number): EventValue[];
+    getProxyAgent(): HttpsProxyAgent<string> | undefined;
+    getConfigJson(): string;
+    shutdown(): void;
+    private requeueFailedEvents;
+}
+export declare const TEST_ONLY: {
+    MAX_RETRY_EVENTS: number;
+    MAX_EVENTS: number;
+    refreshGpuInfo: typeof refreshGpuInfo;
+    resetCachedGpuInfoForTesting: () => void;
+};
+export {};