agent-relay 1.1.0 → 1.2.3

package/dist/hooks/emitter.d.ts

@@ -0,0 +1,40 @@
+/**
+ * HookEmitter
+ *
+ * Lightweight async event emitter for hook handlers.
+ * - Supports async handlers
+ * - Allows stop-propagation via `{ stop: true }` return value
+ * - Can preload handlers from a config object
+ */
+export type EmitterHandlerResult = unknown | {
+    stop?: boolean;
+};
+export type EmitterHandler = (...args: unknown[]) => EmitterHandlerResult | Promise<EmitterHandlerResult>;
+export interface EmitResult {
+    /** Raw results from each handler in order */
+    results: EmitterHandlerResult[];
+    /** Whether propagation was stopped by a handler */
+    stopped: boolean;
+}
+export type EmitterHandlerConfig = Record<string, EmitterHandler | EmitterHandler[]>;
+export declare class HookEmitter {
+    private handlers;
+    constructor(config?: EmitterHandlerConfig);
+    /**
+     * Register a handler for an event.
+     * Returns an unsubscribe function to remove the handler.
+     */
+    on(event: string, handler: EmitterHandler): () => void;
+    /**
+     * Emit an event and invoke handlers sequentially.
+     * If a handler returns `{ stop: true }`, propagation halts.
+     */
+    emit(event: string, ...args: unknown[]): Promise<EmitResult>;
+    /**
+     * Load handlers from a configuration object.
+     * Values can be a single handler or an array of handlers.
+     */
+    load(config: EmitterHandlerConfig): void;
+    private shouldStop;
+}
+//# sourceMappingURL=emitter.d.ts.map

package/dist/hooks/emitter.js

@@ -0,0 +1,63 @@
+/**
+ * HookEmitter
+ *
+ * Lightweight async event emitter for hook handlers.
+ * - Supports async handlers
+ * - Allows stop-propagation via `{ stop: true }` return value
+ * - Can preload handlers from a config object
+ */
+export class HookEmitter {
+    handlers = new Map();
+    constructor(config) {
+        if (config) {
+            this.load(config);
+        }
+    }
+    /**
+     * Register a handler for an event.
+     * Returns an unsubscribe function to remove the handler.
+     */
+    on(event, handler) {
+        const list = this.handlers.get(event) ?? [];
+        list.push(handler);
+        this.handlers.set(event, list);
+        return () => {
+            const updated = this.handlers.get(event)?.filter((fn) => fn !== handler) ?? [];
+            this.handlers.set(event, updated);
+        };
+    }
+    /**
+     * Emit an event and invoke handlers sequentially.
+     * If a handler returns `{ stop: true }`, propagation halts.
+     */
+    async emit(event, ...args) {
+        const results = [];
+        const handlers = this.handlers.get(event) ?? [];
+        let stopped = false;
+        for (const handler of handlers) {
+            const result = await handler(...args);
+            results.push(result);
+            if (this.shouldStop(result)) {
+                stopped = true;
+                break;
+            }
+        }
+        return { results, stopped };
+    }
+    /**
+     * Load handlers from a configuration object.
+     * Values can be a single handler or an array of handlers.
+     */
+    load(config) {
+        for (const [event, handler] of Object.entries(config)) {
+            const handlers = Array.isArray(handler) ? handler : [handler];
+            for (const h of handlers) {
+                this.on(event, h);
+            }
+        }
+    }
+    shouldStop(result) {
+        return typeof result === 'object' && result !== null && 'stop' in result && result.stop === true;
+    }
+}
+//# sourceMappingURL=emitter.js.map

package/dist/hooks/index.d.ts

@@ -4,4 +4,7 @@
  * Entry point for the hooks system types and utilities.
  */
 export * from './types.js';
+export * from './registry.js';
+export * from './trajectory-hooks.js';
+export * from './emitter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -4,4 +4,7 @@
  * Entry point for the hooks system types and utilities.
  */
 export * from './types.js';
+export * from './registry.js';
+export * from './trajectory-hooks.js';
+export * from './emitter.js';
 //# sourceMappingURL=index.js.map

package/dist/hooks/registry.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Hook Registry
+ *
+ * Manages lifecycle hooks and pattern handlers for agent sessions.
+ * Provides a centralized way to register, unregister, and dispatch hooks.
+ */
+import type { HookResult, LifecycleHooks, PatternHandler, HooksConfig } from './types.js';
+/**
+ * Options for creating a HookRegistry
+ */
+export interface HookRegistryOptions {
+    /** Agent identifier */
+    agentId?: string;
+    /** Agent name for relay */
+    agentName?: string;
+    /** Working directory */
+    workingDir?: string;
+    /** Project identifier */
+    projectId?: string;
+    /** Environment variables */
+    env?: Record<string, string | undefined>;
+    /** Task description */
+    task?: string;
+    /** Task ID */
+    taskId?: string;
+    /** Task source */
+    taskSource?: string;
+    /** Idle timeout in ms (default: 30000) */
+    idleTimeout?: number;
+    /** Function to inject text into agent */
+    inject?: (text: string) => void;
+    /** Function to send relay messages */
+    send?: (to: string, body: string) => Promise<void>;
+}
+/**
+ * HookRegistry manages lifecycle hooks and dispatches events
+ */
+export declare class HookRegistry {
+    private sessionId;
+    private agentId;
+    private agentName;
+    private workingDir;
+    private projectId;
+    private env;
+    private task?;
+    private taskId?;
+    private taskSource?;
+    private memory;
+    private relay;
+    private outputHistory;
+    private messageHistory;
+    private sessionStartHooks;
+    private sessionEndHooks;
+    private outputHooks;
+    private messageReceivedHooks;
+    private messageSentHooks;
+    private idleHooks;
+    private errorHooks;
+    private patternHandlers;
+    private idleTimeout;
+    private idleTimer?;
+    private idleCount;
+    private lastActivityTime;
+    private sessionStartTime;
+    private injectFn?;
+    private sendFn?;
+    constructor(options?: HookRegistryOptions);
+    /**
+     * Register hooks from a configuration object
+     */
+    registerHooks(config: HooksConfig): void;
+    /**
+     * Register memory hooks from configuration
+     */
+    private registerMemoryHooksFromConfig;
+    /**
+     * Register memory hooks with custom options
+     */
+    registerMemoryHooks(options?: {
+        type?: string;
+        apiKey?: string;
+        injectOnStart?: boolean;
+        promptOnEnd?: boolean;
+        autoSave?: boolean;
+        autoSaveOnEnd?: boolean;
+    }): Promise<void>;
+    /**
+     * Register lifecycle hooks
+     */
+    registerLifecycleHooks(hooks: LifecycleHooks): void;
+    /**
+     * Add hooks for a specific event
+     */
+    private addHooks;
+    /**
+     * Register a pattern handler
+     */
+    registerPattern(namespace: string, handler: PatternHandler): void;
+    /**
+     * Get the base hook context
+     */
+    private getBaseContext;
+    /**
+     * Run hooks and collect results
+     */
+    private runHooks;
+    /**
+     * Dispatch session start event
+     */
+    dispatchSessionStart(): Promise<HookResult>;
+    /**
+     * Dispatch session end event
+     */
+    dispatchSessionEnd(exitCode?: number, graceful?: boolean): Promise<HookResult>;
+    /**
+     * Dispatch output event
+     */
+    dispatchOutput(content: string, rawContent: string, isComplete?: boolean): Promise<HookResult>;
+    /**
+     * Dispatch message received event
+     */
+    dispatchMessageReceived(from: string, body: string, messageId: string, thread?: string): Promise<HookResult>;
+    /**
+     * Dispatch message sent event
+     */
+    dispatchMessageSent(to: string, body: string, thread?: string): Promise<HookResult>;
+    /**
+     * Dispatch idle event
+     */
+    dispatchIdle(): Promise<HookResult>;
+    /**
+     * Dispatch error event
+     */
+    dispatchError(error: Error, phase?: string): Promise<HookResult>;
+    /**
+     * Check content for pattern matches
+     */
+    private checkPatterns;
+    /**
+     * Start idle timer
+     */
+    private startIdleTimer;
+    /**
+     * Stop idle timer
+     */
+    private stopIdleTimer;
+    /**
+     * Reset idle timer on activity
+     */
+    private resetIdleTimer;
+    /**
+     * Get session info
+     */
+    getSessionInfo(): {
+        sessionId: string;
+        agentId: string;
+        startTime: Date;
+        duration: number;
+    };
+    /**
+     * Update inject function
+     */
+    setInjectFn(fn: (text: string) => void): void;
+    /**
+     * Update send function
+     */
+    setSendFn(fn: (to: string, body: string) => Promise<void>): void;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=registry.d.ts.map