@fenixforce/kernel 0.1.0

package/dist/config/provider-config.d.ts

@@ -0,0 +1,29 @@
+export interface V14SlotConfig {
+    provider: string;
+    model: string;
+    apiKey?: string;
+}
+export type V14ProvidersConfig = Record<string, V14SlotConfig>;
+export interface V15ModalityConfig {
+    model: string;
+}
+export interface V15ProviderEntry {
+    provider: string;
+    apiKeys?: string[];
+    apiKey?: string;
+    modalities: Record<string, V15ModalityConfig>;
+}
+export type V15ProvidersConfig = V15ProviderEntry[];
+export interface ResolvedSlot {
+    slot: string;
+    provider: string;
+    model: string;
+    apiKeys: string[];
+}
+export interface ResolvedProviderConfig {
+    slots: ResolvedSlot[];
+}
+export declare function isV14Format(providers: unknown): providers is V14ProvidersConfig;
+export declare function isV15Format(providers: unknown): providers is V15ProvidersConfig;
+export declare function resolveEnvVar(value: string): string;
+export declare function normalizeProviderConfig(providers: V14ProvidersConfig | V15ProvidersConfig): ResolvedProviderConfig;

package/dist/config/schema.d.ts

@@ -0,0 +1,118 @@
+/**
+ * WorkspaceProfile schema — full configuration surface for a Fenix workspace.
+ */
+export interface ProviderSlot {
+    provider: string;
+    model: string;
+    apiKeyEnv?: string;
+}
+export interface ProvidersConfig {
+    chat: ProviderSlot;
+    utility: ProviderSlot;
+    embedding?: ProviderSlot;
+    vision?: ProviderSlot;
+}
+export interface VoiceConfig {
+    enabled: boolean;
+    sttProvider?: string;
+    sttModel?: string;
+    ttsProvider?: string;
+    ttsModel?: string;
+    ttsVoice?: string;
+    sidecarPort?: number;
+}
+export interface ChannelConfig {
+    type: string;
+    enabled: boolean;
+    tokenEnv?: string;
+    options?: Record<string, unknown>;
+}
+export interface ChannelsConfig {
+    [channelName: string]: ChannelConfig;
+}
+export interface ObservationsConfig {
+    enabled: boolean;
+    captureModel: string;
+    maxResultTruncation: number;
+    autoPromoteThreshold: number;
+    reviewThreshold: number;
+    tensionThreshold: number;
+}
+export interface MemoryConfig {
+    enabled: boolean;
+    backend: string;
+    path?: string;
+    observations: ObservationsConfig;
+}
+export interface RateLimitRule {
+    window: string;
+    max: number;
+}
+export interface SecurityConfig {
+    maxToolIterations: number;
+    loopGuardMaxTotal: number;
+    sandboxTimeout: number;
+    ssrfProtection: boolean;
+    shellBleedAction: "log" | "block" | "abort";
+    rateLimits: Record<string, RateLimitRule>;
+    approvalGates: string[];
+    toolAccess: Record<string, "allow" | "deny" | "approve">;
+}
+export interface CompactionConfig {
+    enabled: boolean;
+    strategy: string;
+    targetTokens: number;
+}
+export interface QualityGatesConfig {
+    enabled: boolean;
+    checks: string[];
+}
+export interface AgentLoopConfig {
+    verbosity: "quiet" | "normal" | "verbose" | "debug";
+    modalLoop: boolean;
+    parallelToolExecution: boolean;
+    wrapupOnLimit: boolean;
+    qualityGates: QualityGatesConfig;
+    compaction: CompactionConfig;
+}
+export interface BudgetsConfig {
+    hourlyUsd?: number;
+    dailyUsd?: number;
+    monthlyUsd?: number;
+}
+export interface WorkspaceProfile {
+    name: string;
+    version: string;
+    providers: ProvidersConfig;
+    voice?: VoiceConfig;
+    channels?: ChannelsConfig;
+    memory?: MemoryConfig;
+    security?: SecurityConfig;
+    agentLoop?: AgentLoopConfig;
+    budgets?: BudgetsConfig;
+}
+export interface V15ModalityEntry {
+    model: string;
+}
+export interface V15ProviderEntry {
+    provider: string;
+    apiKeys?: string[];
+    apiKey?: string;
+    modalities: Record<string, V15ModalityEntry>;
+}
+/** Raw providers input: v1.4 object OR v1.5 array */
+export type ProvidersInput = ProvidersConfig | V15ProviderEntry[];
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export interface WorkspaceProfileInput {
+    name: string;
+    version?: string;
+    providers: ProvidersInput;
+    voice?: DeepPartial<VoiceConfig>;
+    channels?: ChannelsConfig;
+    memory?: DeepPartial<MemoryConfig>;
+    security?: DeepPartial<SecurityConfig>;
+    agentLoop?: DeepPartial<AgentLoopConfig>;
+    budgets?: BudgetsConfig;
+}

package/dist/config/steering-rules.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Steering rules loader — reads markdown rule files from a workspace
+ * rules/ directory and resolves which apply to the current context.
+ *
+ *   rules/always/       → always injected into system prompt
+ *   rules/conditional/  → injected when file/tool/topic conditions match
+ *   rules/manual/       → only when user invokes @rulename or /rule rulename
+ */
+export type RuleKind = "always" | "conditional" | "manual";
+export interface SteeringRule {
+    name: string;
+    kind: RuleKind;
+    priority: number;
+    content: string;
+    fileMatch?: string;
+    toolMatch?: string;
+    topicMatch?: string;
+}
+export interface SteeringRuleSet {
+    rules: SteeringRule[];
+}
+export interface ConversationContext {
+    files?: string[];
+    tools?: string[];
+    userMessage?: string;
+}
+export declare function loadSteeringRules(rulesDir: string): Promise<SteeringRuleSet>;
+export declare function resolveRules(ruleSet: SteeringRuleSet, ctx: ConversationContext): string[];

package/dist/content/chunker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Text Chunker — splits text into overlapping chunks suitable for
+ * embedding and semantic search.
+ *
+ * Features:
+ *  - Configurable max chunk size and overlap
+ *  - Paragraph-aware splitting (prefers breaking at paragraph boundaries)
+ *  - Sentence-aware fallback (splits at sentence boundaries within paragraphs)
+ *  - Character-level fallback for very long unbroken text
+ *  - Simple token estimation (word-based, ~1.3 tokens per word)
+ */
+export interface ChunkOptions {
+    /** Maximum tokens per chunk. Default 512. */
+    maxTokens?: number;
+    /** Overlap tokens between consecutive chunks. Default 64. */
+    overlapTokens?: number;
+    /** Approximate tokens-per-word ratio for estimation. Default 1.3. */
+    tokensPerWord?: number;
+}
+export interface TextChunk {
+    /** Chunk index (0-based). */
+    index: number;
+    /** The chunk text content. */
+    text: string;
+    /** Estimated token count. */
+    estimatedTokens: number;
+    /** Character offset in the original text where this chunk starts. */
+    startOffset: number;
+    /** Character offset in the original text where this chunk ends (exclusive). */
+    endOffset: number;
+}
+/**
+ * Split text into overlapping chunks suitable for embedding.
+ *
+ * Strategy:
+ * 1. Split into paragraphs (double newline)
+ * 2. Accumulate paragraphs into chunks up to maxTokens
+ * 3. If a single paragraph exceeds maxTokens, split on sentences
+ * 4. If a single sentence exceeds maxTokens, hard-split on words/chars
+ * 5. Apply overlap by repeating trailing text from previous chunk
+ */
+export declare function chunkText(text: string, opts?: ChunkOptions): TextChunk[];

package/dist/content/entity-extractor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Entity Extractor — extract structured entities and relations from
+ * content pipeline chunks using an LLM completion function.
+ *
+ * Integrates with the content pipeline (IndexedChunk) and knowledge
+ * graph (ExtractedEntity, ExtractedRelation) to form a bridge between
+ * ingested content and the entity store.
+ */
+import type { IndexedChunk } from "./pipeline.js";
+import type { ExtractedEntity, ExtractedRelation, LLMCompleteFn } from "../memory/knowledge-graph.js";
+export interface EntityExtractionConfig {
+    /** LLM function for generating extractions. */
+    llm: LLMCompleteFn;
+    /** Maximum chunks to process in parallel. Default 5. */
+    concurrency?: number;
+    /** Custom extraction prompt template. Use {text} as placeholder. */
+    promptTemplate?: string;
+}
+export interface ChunkExtractionResult {
+    /** The chunk that was processed. */
+    chunkIndex: number;
+    sourceId: string;
+    /** Extracted entities from this chunk. */
+    entities: ExtractedEntity[];
+    /** Extracted relations from this chunk. */
+    relations: ExtractedRelation[];
+}
+export interface BatchExtractionResult {
+    /** All extractions grouped by chunk. */
+    chunks: ChunkExtractionResult[];
+    /** Deduplicated, merged entities across all chunks. */
+    entities: ExtractedEntity[];
+    /** All relations across all chunks. */
+    relations: ExtractedRelation[];
+    /** Number of chunks processed. */
+    processedCount: number;
+    /** Number of chunks that failed extraction. */
+    errorCount: number;
+}
+export type EntityExtractorEventType = "extraction_start" | "chunk_extracted" | "chunk_error" | "extraction_done";
+export interface EntityExtractorEvent {
+    type: EntityExtractorEventType;
+    timestamp: Date;
+    detail: string;
+    sourceId?: string;
+    chunkIndex?: number;
+}
+export type EntityExtractorEventListener = (event: EntityExtractorEvent) => void;
+export interface EntityExtractor {
+    /** Extract entities/relations from a single chunk. */
+    extractFromChunk(chunk: IndexedChunk): Promise<ChunkExtractionResult>;
+    /** Extract entities/relations from multiple chunks in batch. */
+    extractFromChunks(chunks: IndexedChunk[]): Promise<BatchExtractionResult>;
+    /** Events. */
+    on(listener: EntityExtractorEventListener): void;
+    off(listener: EntityExtractorEventListener): void;
+}
+export declare function createEntityExtractor(config: EntityExtractionConfig): EntityExtractor;

package/dist/content/index.d.ts

@@ -0,0 +1,8 @@
+export { chunkText } from "./chunker.js";
+export type { ChunkOptions, TextChunk } from "./chunker.js";
+export { ContentPipeline, createContentPipeline, _resetPipelineIds, } from "./pipeline.js";
+export type { ContentType, PipelineStage, ContentSource, IndexedChunk, SearchResult, ContentExtractor, EmbedProvider, PipelineJobQueue, PipelineEventType, PipelineEvent, PipelineEventListener, UploadRequest, HttpResult, ContentPipelineConfig, } from "./pipeline.js";
+export { OCREngine, createOCREngine, DEFAULT_PROVIDER_CASCADE } from "./ocr.js";
+export type { OCRProviderName, OCRProvider, OCRInput, BoundingBox, OCRTextBlock, OCRResult, OCREventType, OCREvent, OCREventListener, OCREngineConfig, } from "./ocr.js";
+export { EntityExtractor, createEntityExtractor } from "./entity-extractor.js";
+export type { EntityExtractionConfig, ChunkExtractionResult, BatchExtractionResult, EntityExtractorEventType, EntityExtractorEvent, EntityExtractorEventListener, } from "./entity-extractor.js";

package/dist/content/ocr.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Vision-LLM OCR — provider-agnostic OCR via vision-language models.
+ *
+ * Provider preference cascade (first available wins):
+ *   Chandra → PaddleOCR-VL → Qwen2.5-VL → DeepSeek-OCR → Cloud APIs
+ *
+ * No Surya, Docker, or Python dependencies. Pure TypeScript with
+ * pluggable provider backends.
+ */
+export type OCRProviderName = "chandra" | "paddleocr-vl" | "qwen2.5-vl" | "deepseek-ocr" | "cloud" | (string & {});
+export interface OCRProvider {
+    /** Provider identifier. */
+    name: OCRProviderName;
+    /** Whether this provider is currently available/healthy. */
+    isAvailable(): Promise<boolean>;
+    /** Run OCR on an image and return extracted text. */
+    recognize(input: OCRInput): Promise<OCRResult>;
+}
+export interface OCRInput {
+    /** Image data as base64-encoded string. */
+    imageBase64: string;
+    /** MIME type (e.g. "image/png", "image/jpeg"). */
+    mimeType: string;
+    /** Optional language hint (e.g. "en", "zh"). */
+    language?: string;
+    /** Optional: request structured output (bounding boxes). */
+    structured?: boolean;
+}
+export interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface OCRTextBlock {
+    text: string;
+    confidence: number;
+    boundingBox?: BoundingBox;
+}
+export interface OCRResult {
+    /** Full extracted text. */
+    text: string;
+    /** Provider that produced this result. */
+    provider: OCRProviderName;
+    /** Individual text blocks (if structured output requested). */
+    blocks: OCRTextBlock[];
+    /** Processing time in milliseconds. */
+    durationMs: number;
+}
+export type OCREventType = "provider_selected" | "provider_unavailable" | "ocr_start" | "ocr_done" | "ocr_error" | "fallback";
+export interface OCREvent {
+    type: OCREventType;
+    timestamp: Date;
+    provider?: OCRProviderName;
+    detail: string;
+}
+export type OCREventListener = (event: OCREvent) => void;
+/** Default provider cascade order. */
+export declare const DEFAULT_PROVIDER_CASCADE: OCRProviderName[];
+export interface OCREngineConfig {
+    /** Registered providers (order matters for cascade). */
+    providers: OCRProvider[];
+    /** Override the default cascade order. If omitted, uses registration order. */
+    cascadeOrder?: OCRProviderName[];
+    /** Maximum retries on provider failure before trying next. Default 1. */
+    maxRetries?: number;
+}
+export interface OCREngine {
+    /** Run OCR with automatic provider cascade. */
+    recognize(input: OCRInput): Promise<OCRResult>;
+    /** Check which providers are currently available. */
+    availableProviders(): Promise<OCRProviderName[]>;
+    /** List all registered providers. */
+    listProviders(): OCRProviderName[];
+    /** Events. */
+    on(listener: OCREventListener): void;
+    off(listener: OCREventListener): void;
+}
+export declare function createOCREngine(config: OCREngineConfig): OCREngine;

package/dist/content/pipeline.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Content Ingestion Pipeline — full content lifecycle:
+ *   upload → extract → chunk → embed → index
+ *
+ * Features:
+ *  - Pluggable content extractors (text, HTML, markdown, PDF, etc.)
+ *  - Pluggable embed provider (maps chunk text → vector)
+ *  - In-memory vector store with cosine similarity search
+ *  - Job queue integration for async processing
+ *  - Framework-agnostic HTTP endpoint handlers
+ *  - Full event system for monitoring pipeline stages
+ *  - Source management (status, deletion)
+ */
+import type { ChunkOptions } from "./chunker.js";
+export declare function _resetPipelineIds(): void;
+export type ContentType = "text" | "html" | "markdown" | "pdf" | "json";
+export type PipelineStage = "uploaded" | "extracting" | "chunking" | "embedding" | "indexing" | "ready" | "failed";
+export interface ContentSource {
+    id: string;
+    /** Original file name or label. */
+    name: string;
+    contentType: ContentType;
+    /** Current pipeline stage. */
+    stage: PipelineStage;
+    /** Number of chunks produced. */
+    chunkCount: number;
+    /** Error message if stage is "failed". */
+    error?: string;
+    /** Size of original content in bytes. */
+    sizeBytes: number;
+    createdAt: Date;
+    updatedAt: Date;
+    /** Optional metadata attached at upload time. */
+    metadata?: Record<string, unknown>;
+}
+export interface IndexedChunk {
+    /** Source ID this chunk belongs to. */
+    sourceId: string;
+    /** Chunk index within the source. */
+    chunkIndex: number;
+    /** The chunk text. */
+    text: string;
+    /** Estimated token count. */
+    estimatedTokens: number;
+    /** Embedding vector. */
+    vector: number[];
+    /** Character offset in original extracted text. */
+    startOffset: number;
+    endOffset: number;
+}
+export interface SearchResult {
+    /** The matched chunk. */
+    chunk: IndexedChunk;
+    /** Cosine similarity score (0-1). */
+    score: number;
+    /** The content source this chunk belongs to. */
+    source: ContentSource;
+}
+/**
+ * Content extractor: transforms raw content into plain text for chunking.
+ */
+export interface ContentExtractor {
+    /** Content types this extractor handles. */
+    types: ContentType[];
+    /** Extract plain text from raw content. */
+    extract(raw: string, contentType: ContentType): Promise<string>;
+}
+/**
+ * Embedding provider: maps text to a vector.
+ */
+export interface EmbedProvider {
+    /** Dimension of output vectors. */
+    dimensions: number;
+    /** Embed a single text string. */
+    embed(text: string): Promise<number[]>;
+    /** Batch embed multiple texts. Returns vectors in same order. */
+    embedBatch?(texts: string[]): Promise<number[][]>;
+}
+export interface PipelineJobQueue {
+    enqueue(type: string, payload: unknown, chatId?: string): {
+        id: string;
+    };
+}
+export type PipelineEventType = "source_uploaded" | "extraction_start" | "extraction_done" | "chunking_start" | "chunking_done" | "embedding_start" | "embedding_done" | "indexing_done" | "source_ready" | "source_failed" | "source_deleted" | "search_executed";
+export interface PipelineEvent {
+    type: PipelineEventType;
+    timestamp: Date;
+    sourceId?: string;
+    detail: string;
+}
+export type PipelineEventListener = (event: PipelineEvent) => void;
+export interface UploadRequest {
+    /** Content as a string. */
+    content: string;
+    /** File name or label. */
+    name: string;
+    /** Content type. Default "text". */
+    contentType?: ContentType;
+    /** Optional metadata. */
+    metadata?: Record<string, unknown>;
+}
+export interface HttpResult {
+    status: number;
+    body: Record<string, unknown>;
+}
+export interface ContentPipelineConfig {
+    /** Embedding provider. Required. */
+    embedProvider: EmbedProvider;
+    /** Custom content extractors. Merged with defaults. */
+    extractors?: ContentExtractor[];
+    /** Chunk options passed to the text chunker. */
+    chunkOptions?: ChunkOptions;
+    /** Optional job queue for async processing. */
+    queue?: PipelineJobQueue;
+    /** Job type for async ingestion. Default "tool.execute". */
+    jobType?: string;
+}
+export interface ContentPipeline {
+    /**
+     * Ingest content through the full pipeline.
+     * Returns the content source with stage "ready" on success.
+     */
+    ingest(request: UploadRequest): Promise<ContentSource>;
+    /** Get the status of a content source by ID. */
+    getStatus(sourceId: string): ContentSource | undefined;
+    /** List all content sources. */
+    listSources(): ContentSource[];
+    /**
+     * Search indexed chunks by query text.
+     * Embeds the query, then finds top-k chunks by cosine similarity.
+     */
+    search(query: string, opts?: {
+        topK?: number;
+        minScore?: number;
+        sourceId?: string;
+    }): Promise<SearchResult[]>;
+    /** Delete a source and all its indexed chunks. */
+    deleteSource(sourceId: string): boolean;
+    /** Handle POST /api/v1/content/upload */
+    handleUpload(body: unknown): Promise<HttpResult>;
+    /** Handle GET /api/v1/content/:id */
+    handleGetStatus(sourceId: string): HttpResult;
+    /** Handle GET /api/v1/content/search?q=... */
+    handleSearch(query: string, opts?: {
+        topK?: number;
+        sourceId?: string;
+    }): Promise<HttpResult>;
+    /** Handle DELETE /api/v1/content/:id */
+    handleDelete(sourceId: string): HttpResult;
+    on(listener: PipelineEventListener): void;
+    off(listener: PipelineEventListener): void;
+}
+export declare function createContentPipeline(config: ContentPipelineConfig): ContentPipeline;

package/dist/context-overflow.d.ts

@@ -0,0 +1,19 @@
+import type { Message, LLMProvider } from "./providers/interface.js";
+import type { AgentEvent } from "./events/types.js";
+export interface OverflowContext {
+    contextWindowTokens?: number;
+    utilityProvider?: LLMProvider;
+    utilityModel?: string;
+    sessionId?: string;
+}
+export interface OverflowResult {
+    messages: Message[];
+    stage: number;
+    strategy: string;
+}
+export declare function estimateTokens(messages: Message[]): number;
+export declare function contextOverflowRecovery(messages: Message[], context: OverflowContext): AsyncGenerator<AgentEvent, OverflowResult>;
+export declare function contextOverflowCheck(messages: Message[], contextWindowTokens?: number): {
+    ratio: number;
+    overLimit: boolean;
+};

package/dist/editions/mobile.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+/**
+ * Fenix Agent — Mobile Edition
+ *
+ * Lightweight edition with:
+ *  - Real agent loop (LLM-powered responses)
+ *  - Telegram channel adapter (long-polling)
+ *  - Single-threaded worker (no pool)
+ *  - Local-only job types (no browser, scrape, image gen)
+ *  - Job tool router registered
+ */
+export {};

package/dist/editions/pro.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+/**
+ * Fenix Agent — Pro Edition
+ *
+ * Full-featured edition with:
+ *  - Real agent loop (LLM-powered responses)
+ *  - Telegram channel adapter (long-polling)
+ *  - Job queue with worker pool (default 3 workers)
+ *  - All job types enabled
+ *  - Job tool router registered
+ */
+export {};

package/dist/editions/voices.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+/**
+ * Fenix Agent — Voices Edition
+ *
+ * Voice-first edition with:
+ *  - Real agent loop (LLM-powered responses)
+ *  - Telegram channel adapter (long-polling)
+ *  - Job queue with worker pool (default 3 workers)
+ *  - All job types enabled (including audio.transcribe, image.generate)
+ *  - Voice/audio-specific job priorities
+ *  - Voice pipeline (SidecarManager, SpeechQueue, markers)
+ *  - Job tool router registered
+ */
+export {};

package/dist/events/block-manager.d.ts

@@ -0,0 +1,37 @@
+import type { Block, BlockType, BlockPatch } from "./types.js";
+import type { EventBus } from "./bus.js";
+export interface BlockManagerConfig {
+    /** Event bus for emitting block events */
+    bus: EventBus;
+    /** Session ID for event context */
+    sessionId: string;
+}
+/**
+ * Manages structured blocks and emits events through the EventBus.
+ *
+ * Usage:
+ * - `emitBlock("text", "Hello")` → creates block, emits `block:emitted`
+ * - `updateBlock(id, [{ op: "append", path: "data", value: " world" }])`
+ *   → patches block in-place, emits `block:updated` per patch
+ *
+ * Clients maintain a local block map and apply patches as they arrive.
+ */
+export declare class EventBlockManager {
+    private blocks;
+    private nextId;
+    private bus;
+    private sessionId;
+    constructor(config: BlockManagerConfig);
+    /** Create and emit a new block. Returns the block ID. */
+    emitBlock(type: BlockType, data: unknown): Promise<string>;
+    /** Apply patches to an existing block. Returns false if block not found. */
+    updateBlock(blockId: string, patches: BlockPatch[]): Promise<boolean>;
+    /** Get a block by ID. */
+    getBlock(blockId: string): Block | undefined;
+    /** Get all blocks in creation order. */
+    getAllBlocks(): Block[];
+    /** Total blocks managed. */
+    get size(): number;
+    /** Apply a single patch to a block in-place. */
+    private applyPatch;
+}

package/dist/events/bus.d.ts

@@ -0,0 +1,39 @@
+import type { AgentEvent, AgentEventType } from "./types.js";
+export type EventHandler<T extends AgentEvent = AgentEvent> = (event: T) => void | Promise<void>;
+export type ErrorHandler = (error: unknown, event: AgentEvent) => void;
+export declare class EventBus {
+    private handlers;
+    private allHandlers;
+    private errorHandler?;
+    /** "soon" events — drained on next microtask. */
+    private soonQueue;
+    private soonScheduled;
+    /** "later" events — drained explicitly via drainDeferred(). */
+    private laterQueue;
+    /** Subscribe to a specific event type. Returns an unsubscribe function. */
+    subscribe<T extends AgentEventType>(type: T, handler: EventHandler<Extract<AgentEvent, {
+        type: T;
+    }>>): () => void;
+    /** Subscribe to all events. Returns an unsubscribe function. */
+    subscribeAll(handler: EventHandler<AgentEvent>): () => void;
+    /** Set error handler for handler failures (error isolation). */
+    onError(handler: ErrorHandler): void;
+    /**
+     * Emit an event with urgency-aware delivery.
+     *
+     * - immediate: delivered synchronously (default, backward-compatible)
+     * - soon: queued and delivered on next microtask
+     * - later: queued and delivered when drainDeferred() is called
+     */
+    emit(event: AgentEvent): Promise<void>;
+    /** Drain all "later" events (call when agent is idle). */
+    drainDeferred(): Promise<number>;
+    /** Number of pending "soon" + "later" events. */
+    get pendingCount(): number;
+    /** Count of handlers for a specific type, or total if omitted. */
+    listenerCount(type?: AgentEventType): number;
+    /** Remove all handlers and flush queues. */
+    clear(): void;
+    private deliver;
+    private scheduleSoonDrain;
+}

package/dist/events/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export { EventBus, type EventHandler, type ErrorHandler } from "./bus.js";
+export { pipeToEventBus, collectEvents, type StreamAdapterConfig } from "./stream-adapter.js";
+export { setupDualWebSocket, type WebSocketChannel, type WebSocketMessage, type WebSocketSender, type DualWebSocketConfig, } from "./websocket.js";
+export { EventBlockManager } from "./block-manager.js";
+export type { BlockManagerConfig } from "./block-manager.js";
+export { SessionManager } from "./session-manager.js";
+export type { EventListener, Session, SessionManagerConfig } from "./session-manager.js";