@fenixforce/kernel 0.1.0

package/dist/channels/http-api.d.ts

@@ -0,0 +1,155 @@
+/**
+ * HTTP API — Hono-based server exposing the full Fenix API surface.
+ *
+ * Routes:
+ * - POST   /api/v1/messages           — send message, SSE response
+ * - GET    /api/v1/conversations       — list conversations
+ * - POST   /api/v1/conversations       — create conversation
+ * - DELETE /api/v1/conversations/:id   — delete conversation
+ * - GET    /api/v1/memory/search       — search memory
+ * - GET    /api/v1/memory/profile      — get user profile
+ * - GET    /api/v1/memory/graph        — query knowledge graph
+ * - GET    /api/v1/jobs                — list jobs
+ * - POST   /api/v1/jobs                — submit job
+ * - DELETE /api/v1/jobs/:id            — cancel job
+ * - POST   /api/v1/webhooks/:id        — webhook callback
+ * - POST   /api/v1/approvals/:id       — approval response
+ * - GET    /api/v1/tasks               — list tasks
+ * - GET    /api/v1/traces              — get traces
+ * - GET    /api/v1/costs               — get cost summary
+ * - GET    /api/v1/health              — health check
+ * - GET    /api/v1/config              — workspace config
+ * - GET    /api/v1/sessions/:id/reconnect — replay missed events (SSE)
+ *
+ * WebSocket channels: /ws/events, /ws/workspace
+ */
+import type { AgentEvent } from "../events/types.js";
+import type { EventBus } from "../events/bus.js";
+import type { SessionManager } from "../events/session-manager.js";
+interface HonoContext {
+    req: {
+        param(name: string): string;
+        query(name: string): string | undefined;
+        json<T = unknown>(): Promise<T>;
+        header(name: string): string | undefined;
+    };
+    json(data: unknown, status?: number): Response;
+    text(data: string, status?: number): Response;
+    header(name: string, value: string): void;
+    body(data: ReadableStream | string | null, status?: number): Response;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+}
+interface HonoApp {
+    get(path: string, ...handlers: Array<(c: HonoContext) => Response | Promise<Response>>): void;
+    post(path: string, ...handlers: Array<(c: HonoContext) => Response | Promise<Response>>): void;
+    delete(path: string, ...handlers: Array<(c: HonoContext) => Response | Promise<Response>>): void;
+    use(path: string, ...handlers: Array<(c: HonoContext, next: () => Promise<void>) => Response | Promise<Response | void>>): void;
+}
+export interface MessageInput {
+    userId: string;
+    conversationId?: string;
+    content: string;
+    channel?: string;
+    attachments?: Array<{
+        type: string;
+        url?: string;
+        base64?: string;
+    }>;
+}
+export interface APIHandlers {
+    /** Send a message and receive streaming agent events */
+    sendMessage(input: MessageInput): AsyncIterable<AgentEvent>;
+    /** Conversations */
+    listConversations(userId: string, limit?: number, offset?: number): Promise<unknown[]>;
+    createConversation(userId: string, title?: string, channel?: string): Promise<unknown>;
+    deleteConversation(id: string): Promise<void>;
+    /** Memory */
+    searchMemory(userId: string, query: string, limit?: number): Promise<unknown[]>;
+    getProfile(userId: string): Promise<unknown>;
+    queryGraph(userId: string, entity: string): Promise<unknown>;
+    /** Jobs */
+    listJobs(status?: string, type?: string): Promise<unknown[]>;
+    submitJob(type: string, payload: unknown, priority?: string): Promise<unknown>;
+    cancelJob(id: string): Promise<void>;
+    /** Webhooks */
+    handleWebhook(id: string, payload: unknown): Promise<unknown>;
+    /** Approvals */
+    respondApproval(id: string, approved: boolean, reason?: string): Promise<unknown>;
+    /** Tasks, traces, costs */
+    listTasks(status?: string): Promise<unknown[]>;
+    getTraces(sessionId?: string, limit?: number): Promise<unknown[]>;
+    getCosts(userId?: string, period?: string): Promise<unknown>;
+    /** Config */
+    getConfig(): Promise<unknown>;
+}
+export interface HTTPAPIConfig {
+    handlers: APIHandlers;
+    bus: EventBus;
+    sessionManager: SessionManager;
+    /**
+     * Enable stateless mode. When true, POST /api/v1/stateless/chat
+     * accepts full history + state from the client and returns updated
+     * state. No server-side session storage. Enables serverless/Lambda.
+     */
+    stateless?: boolean;
+}
+export interface StatelessRequest {
+    /** Full conversation history. */
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** Client-side state to restore. */
+    state?: Record<string, unknown>;
+    /** User identifier. */
+    userId: string;
+    /** Optional model override. */
+    model?: string;
+}
+export interface StatelessResponse {
+    /** Updated conversation with assistant reply appended. */
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** Updated state for the client to persist. */
+    state: Record<string, unknown>;
+    /** Events generated during processing. */
+    events: unknown[];
+    /** Token usage. */
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+/**
+ * Register all API routes on a Hono app instance.
+ *
+ * Usage:
+ * ```ts
+ * import { Hono } from "hono";
+ * const app = new Hono();
+ * registerAPIRoutes(app, { handlers, bus, sessionManager });
+ * ```
+ */
+export declare function registerAPIRoutes(app: HonoApp, config: HTTPAPIConfig): void;
+export interface WSUpgradeContext {
+    sessionId: string;
+    channel: "events" | "workspace";
+}
+/**
+ * Handle WebSocket upgrade for /ws/events and /ws/workspace.
+ *
+ * This is a helper for Bun's native WebSocket or Hono's ws adapter.
+ * The consumer is responsible for the actual upgrade; this function
+ * wires the event bus to the socket.
+ */
+export declare function wireWebSocket(ws: {
+    send(data: string): void;
+    close(): void;
+}, context: WSUpgradeContext, config: {
+    bus: EventBus;
+    sessionManager: SessionManager;
+}): () => void;
+export {};

package/dist/channels/index.d.ts

@@ -0,0 +1,20 @@
+export { createTelegramChannelAdapter, splitMessage, statusIcon, formatElapsed } from "./telegram.js";
+export type { STTProvider, TTSProvider, AdapterMode, ModeIndicator, TelegramAdapterConfig, TelegramChannelAdapter, MessageEnvelope, MessageHandler, Attachment, TaskInfo, JobInfo, PendingApproval, InlineKeyboardMarkup, InlineKeyboardButton, TelegramUpdate, TelegramMessage, TelegramUser, TelegramChat, TelegramCallbackQuery, TelegramPhotoSize, TelegramDocument, TelegramVoice, } from "./telegram.js";
+export { registerAPIRoutes, wireWebSocket, type APIHandlers, type HTTPAPIConfig } from "./http-api.js";
+export { registerOpenAIRoutes, type OpenAICompatRouteConfig } from "./openai-compat.js";
+export { createWhatsAppAdapter } from "./whatsapp.js";
+export type { WhatsAppConfig, WhatsAppChannelAdapter, WAInboundMessage, WhatsAppAdapterEvent, WhatsAppEventHandler } from "./whatsapp.js";
+export { createDiscordAdapter } from "./discord.js";
+export type { DiscordConfig, DiscordChannelAdapter, DiscordMessage, DiscordInteraction, DiscordAttachment } from "./discord.js";
+export { createSlackAdapter } from "./slack.js";
+export type { SlackConfig, SlackChannelAdapter, SlackEventPayload, SlackEvent, SlackSlashCommand, SlackInteraction } from "./slack.js";
+export { createSignalAdapter } from "./signal.js";
+export type { SignalConfig, SignalChannelAdapter, SignalInboundMessage, SignalAttachmentInfo } from "./signal.js";
+export { createEmailAdapter } from "./email.js";
+export type { EmailConfig, EmailChannelAdapter, InboundEmail, OutboundEmail, EmailAttachment } from "./email.js";
+export { createTeamsAdapter } from "./teams.js";
+export type { TeamsConfig, TeamsChannelAdapter, TeamsActivity, TeamsActivityResponse, ConversationReference, PendingTeamsApproval } from "./teams.js";
+export { createMcpChannelAdapter } from "./mcp-channel.js";
+export type { McpChannelConfig, McpChannelAdapter, McpAgentStatus, McpMemoryResult, McpResource, JsonRpcRequest, JsonRpcResponse } from "./mcp-channel.js";
+export { createChannelRegistry } from "./registry.js";
+export type { ChannelRegistry, ChannelRegistryConfig, ChannelStatus, ChannelAccessConfig, ChannelRegistryEvent, RegisteredChannel } from "./registry.js";

package/dist/channels/mcp-channel.d.ts

@@ -0,0 +1,75 @@
+/**
+ * MCP Channel Adapter
+ *
+ * Exposes the Fenix agent as an MCP (Model Context Protocol) server so that
+ * MCP clients (Claude Desktop, Cursor, Windsurf, other agents) can interact
+ * with it as a tool provider.
+ *
+ * Transports:
+ *   - "stdio"  → for local integrations (client spawns Fenix as subprocess)
+ *   - "sse"    → for remote integrations over HTTP (Server-Sent Events)
+ */
+import type { MessageHandler } from "./types.js";
+export interface McpChannelConfig {
+    transport: "stdio" | "sse";
+    /** SSE mode port. Default: 3100 */
+    port?: number;
+    /** SSE mode path. Default: "/mcp" */
+    path?: string;
+    /** Simple bearer token validation. */
+    apiKey?: string;
+    /** Message handler (injected by kernel). */
+    onMessage: MessageHandler;
+    /** Agent status callback. */
+    getStatus?: () => McpAgentStatus;
+    /** Memory search callback. */
+    memorySearch?: (query: string, limit?: number) => Promise<McpMemoryResult[]>;
+    /** Resources exposed to MCP clients. */
+    resources?: McpResource[];
+    /** Override for testing — inject a request handler. */
+    handleJsonRpc?: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+}
+export interface McpAgentStatus {
+    state: "idle" | "busy" | "error";
+    activeConversations: number;
+    uptime: number;
+    version?: string;
+}
+export interface McpMemoryResult {
+    content: string;
+    similarity: number;
+    metadata?: Record<string, unknown>;
+}
+export interface McpResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    content: string | (() => string | Promise<string>);
+}
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface McpChannelAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Process a JSON-RPC request and return a response. */
+    handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    readonly isRunning: boolean;
+    readonly transport: "stdio" | "sse";
+    readonly sessionCount: number;
+}
+export declare function createMcpChannelAdapter(config: McpChannelConfig): McpChannelAdapter;

package/dist/channels/mobile-hil.d.ts

@@ -0,0 +1,88 @@
+export interface HILQuestion {
+    id: string;
+    agentInstanceId: string;
+    sessionId: string;
+    question: string;
+    context?: string;
+    timeout: number;
+    createdAt: number;
+}
+export interface HILAnswer {
+    questionId: string;
+    answer: string;
+    answeredAt: number;
+}
+export type HILStatus = "pending" | "answered" | "timeout";
+export interface HILRecord {
+    question: HILQuestion;
+    answer?: HILAnswer;
+    status: HILStatus;
+}
+export type HILEventType = "hil:question" | "hil:answered" | "hil:timeout";
+export interface HILEvent {
+    type: HILEventType;
+    questionId: string;
+    sessionId: string;
+    agentInstanceId: string;
+    timestamp: number;
+}
+export type HILEventHandler = (event: HILEvent) => void;
+/** Push notification sender interface. */
+export interface PushNotificationSender {
+    send(payload: PushNotificationPayload): Promise<void>;
+}
+export interface PushNotificationPayload {
+    title: string;
+    body: string;
+    data: {
+        type: "hil:question";
+        agentInstanceId: string;
+        sessionId: string;
+        questionId: string;
+    };
+}
+/** Storage for pending HIL questions. */
+export interface HILStore {
+    save(record: HILRecord): Promise<void>;
+    get(questionId: string): Promise<HILRecord | null>;
+    update(questionId: string, answer: HILAnswer): Promise<void>;
+    listPending(sessionId: string): Promise<HILRecord[]>;
+}
+export interface MobileHILConfig {
+    pushSender: PushNotificationSender;
+    store: HILStore;
+    /** Default timeout in seconds. */
+    defaultTimeout?: number;
+}
+export declare class MobileHILChannel {
+    private config;
+    private waiters;
+    private handlers;
+    constructor(config: MobileHILConfig);
+    /**
+     * Ask the user a question. Sends push notification, pauses
+     * execution until answer or timeout.
+     */
+    ask(agentInstanceId: string, sessionId: string, question: string, opts?: {
+        timeout?: number;
+        context?: string;
+    }): Promise<string>;
+    /**
+     * Submit an answer to a pending question.
+     * Called when the user responds via mobile app.
+     */
+    answer(questionId: string, answerText: string): Promise<void>;
+    /** Subscribe to HIL events. */
+    on(handler: HILEventHandler): () => void;
+    /** Clean up all pending waiters. */
+    dispose(): void;
+    private emit;
+}
+export declare class HILTimeoutError extends Error {
+    readonly questionId: string;
+    readonly timeoutSeconds: number;
+    constructor(questionId: string, timeoutSeconds: number);
+}
+export declare function createInMemoryHILStore(): HILStore;
+/** Reset ID counter for tests. */
+export declare function _resetHILIds(): void;

package/dist/channels/openai-compat.d.ts

@@ -0,0 +1,42 @@
+/**
+ * OpenAI-Compatible Channel — registers POST /v1/chat/completions on
+ * the HTTP API so that any app using the OpenAI SDK can drop in Fenix
+ * as a replacement.
+ *
+ * Delegates to the core handler in ../api/openai-compat.ts and adds
+ * route-level middleware (auth, CORS, content-type negotiation).
+ */
+import { type OpenAICompatConfig, type OpenAICompatHandler } from "../api/openai-compat.js";
+interface HonoContext {
+    req: {
+        param(name: string): string;
+        query(name: string): string | undefined;
+        json<T = unknown>(): Promise<T>;
+        header(name: string): string | undefined;
+    };
+    json(data: unknown, status?: number): Response;
+    text(data: string, status?: number): Response;
+    header(name: string, value: string): void;
+    body(data: ReadableStream | string | null, status?: number): Response;
+}
+interface HonoApp {
+    post(path: string, ...handlers: Array<(c: HonoContext) => Response | Promise<Response>>): void;
+    get(path: string, ...handlers: Array<(c: HonoContext) => Response | Promise<Response>>): void;
+}
+export interface OpenAICompatRouteConfig extends OpenAICompatConfig {
+    /** Optional bearer token for auth. If set, requests must include
+     *  `Authorization: Bearer <token>`. */
+    bearerToken?: string;
+    /** Base path prefix. Default: "" (mounts at /v1/chat/completions). */
+    basePath?: string;
+}
+/**
+ * Register OpenAI-compatible routes on a Hono app:
+ *   POST /v1/chat/completions — chat completion (streaming + non-streaming)
+ *   GET  /v1/models           — list available models
+ *
+ * Returns the handler for event subscription.
+ */
+export declare function registerOpenAIRoutes(app: HonoApp, config: OpenAICompatRouteConfig): OpenAICompatHandler;
+export { createOpenAICompatHandler, validateRequest, _resetCompletionIds, } from "../api/openai-compat.js";
+export type { ChatRole, ChatMessage, ChatCompletionRequest, ChatCompletionChoice, CompletionUsage, ChatCompletionResponse, ChatCompletionChunkDelta, ChatCompletionChunkChoice, ChatCompletionChunk, AgentCompletionResult, AgentCompletionFn, AgentStreamFn, CompatEventType, CompatEvent, CompatEventListener, ValidationError, OpenAICompatConfig, OpenAICompatHandler, } from "../api/openai-compat.js";

package/dist/channels/registry.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Channel Registry
+ *
+ * Unified channel management: registration, lifecycle, access control,
+ * per-channel identity overrides, and health monitoring.
+ */
+import type { ChannelAdapter } from "./types.js";
+export interface ChannelStatus {
+    name: string;
+    enabled: boolean;
+    connected: boolean;
+    messageCount: number;
+    lastMessageAt?: Date;
+    allowList?: string[];
+}
+export interface ChannelAccessConfig {
+    channelName: string;
+    /** User identifiers permitted on this channel. Empty = allow all. */
+    allowFrom: string[];
+    /** Explicit block list (takes precedence over allowFrom). */
+    denyFrom?: string[];
+    requireConsent?: boolean;
+    rateLimitPerMinute?: number;
+}
+export interface ChannelRegistryConfig {
+    /** Per-channel access rules. */
+    accessRules?: ChannelAccessConfig[];
+    /** Base path for identity override files. */
+    identityOverridePath?: string;
+    /** Event emitter callback. */
+    onEvent?: (event: ChannelRegistryEvent) => void;
+    /** Override for testing — load identity override from channel name. */
+    loadOverride?: (channelName: string) => Promise<string | null>;
+    /** Rejection message for denied users. Null = silent drop. */
+    rejectionMessage?: string | null;
+}
+export type ChannelRegistryEvent = {
+    type: "channel:connected";
+    channel: string;
+} | {
+    type: "channel:disconnected";
+    channel: string;
+} | {
+    type: "channel:error";
+    channel: string;
+    error: string;
+} | {
+    type: "channel:message";
+    channel: string;
+    userId: string;
+} | {
+    type: "channel:denied";
+    channel: string;
+    userId: string;
+    reason: string;
+};
+export interface RegisteredChannel {
+    name: string;
+    adapter: ChannelAdapter;
+    enabled: boolean;
+}
+export interface ChannelRegistry {
+    register(name: string, adapter: ChannelAdapter): void;
+    unregister(name: string): void;
+    start(channelName: string): Promise<void>;
+    stop(channelName: string): Promise<void>;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    list(): ChannelStatus[];
+    getAdapter(name: string): ChannelAdapter | undefined;
+    /** Check whether a user is allowed on a channel. */
+    isAllowed(channelName: string, userId: string): boolean;
+    /** Load identity override for a channel (null if none). */
+    getIdentityOverride(channelName: string): Promise<string | null>;
+    /** Get message stats for a channel. */
+    getStats(channelName: string): ChannelStatus | undefined;
+    /** Record an inbound message (for stats tracking). */
+    recordMessage(channelName: string, userId: string): void;
+}
+export declare function createChannelRegistry(config?: ChannelRegistryConfig): ChannelRegistry;

package/dist/channels/signal.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Signal Channel Adapter
+ *
+ * Privacy-focused channel adapter communicating with signal-cli daemon
+ * over JSON-RPC (Unix socket or stdin/stdout). GPL boundary is maintained
+ * via IPC — no GPL code is linked into Fenix.
+ *
+ * Two backends:
+ *   - "signal-cli"  → spawns or connects to signal-cli daemon
+ *   - "signald"     → connects to signald JSON-RPC over Unix socket
+ */
+import type { MessageHandler } from "./types.js";
+import type { STTProvider, TTSProvider } from "./telegram.js";
+export interface SignalConfig {
+    mode: "signal-cli" | "signald";
+    /** Registered Signal phone number (e.g. "+15551234567"). */
+    phoneNumber: string;
+    onMessage: MessageHandler;
+    /** Path to signal-cli binary (signal-cli mode). */
+    signalCliPath?: string;
+    /** Unix socket path (signald mode). Default: /var/run/signald/signald.sock */
+    socketPath?: string;
+    /** Phone number allow-list. Empty = allow all. */
+    allowedNumbers?: string[];
+    stt?: STTProvider;
+    tts?: TTSProvider;
+    /** Override for testing — inject a mock RPC transport. */
+    rpcSend?: (method: string, params: Record<string, unknown>) => Promise<unknown>;
+    /** Override for testing — inject inbound messages. */
+    onRpcMessage?: (handler: (msg: SignalInboundMessage) => void) => void;
+}
+/** Inbound message from signal-cli JSON-RPC. */
+export interface SignalInboundMessage {
+    envelope: {
+        source: string;
+        sourceName?: string;
+        sourceDevice?: number;
+        timestamp: number;
+        dataMessage?: {
+            message?: string;
+            attachments?: SignalAttachmentInfo[];
+            groupInfo?: {
+                groupId: string;
+                groupName?: string;
+            };
+            expiresInSeconds?: number;
+            reaction?: {
+                emoji: string;
+                targetTimestamp: number;
+            };
+        };
+        receiptMessage?: {
+            type: string;
+            timestamps: number[];
+        };
+    };
+}
+export interface SignalAttachmentInfo {
+    contentType: string;
+    filename?: string;
+    id: string;
+    size?: number;
+    /** Local file path where signal-cli stored the downloaded attachment. */
+    storedFilename?: string;
+}
+export interface SignalChannelAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(conversationId: string, text: string): Promise<void>;
+    /** Process an inbound signal-cli JSON-RPC message (for testing). */
+    handleInbound(message: SignalInboundMessage): Promise<void>;
+    readonly isRunning: boolean;
+    readonly mode: "signal-cli" | "signald";
+}
+export declare function createSignalAdapter(config: SignalConfig): SignalChannelAdapter;

package/dist/channels/slack.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Slack Channel Adapter
+ *
+ * Two connection modes:
+ *   - Socket Mode  → real-time messaging via WebSocket (no public URL required)
+ *   - HTTP Mode    → webhook-based with signature verification
+ *
+ * Supports threaded conversations, Block Kit rich formatting,
+ * slash commands, file uploads, App Home tab, and user identity mapping.
+ */
+import type { MessageHandler } from "./types.js";
+import type { STTProvider, TTSProvider, TaskInfo, JobInfo } from "./telegram.js";
+export interface SlackConfig {
+    /** Bot user OAuth token (xoxb-...) */
+    botToken: string;
+    /** App-level token for Socket Mode (xapp-...) */
+    appToken: string;
+    /** Signing secret for HTTP mode webhook verification. */
+    signingSecret?: string;
+    /** "socket" for self-hosted, "http" for cloud. Default: "socket". */
+    mode: "socket" | "http";
+    onMessage: MessageHandler;
+    onReset?: (conversationId: string) => Promise<string>;
+    onTasks?: (conversationId: string) => Promise<TaskInfo[]>;
+    onJobs?: (conversationId: string) => Promise<JobInfo[]>;
+    /** Restrict to specific channels. */
+    allowedChannelIds?: string[];
+    /** Map Slack user IDs to Fenix user IDs. */
+    userIdMap?: Record<string, string>;
+    stt?: STTProvider;
+    tts?: TTSProvider;
+    /** Override fetch for testing. */
+    fetchFn?: typeof globalThis.fetch;
+}
+/** Slack event wrapper. */
+export interface SlackEventPayload {
+    type: string;
+    challenge?: string;
+    token?: string;
+    event?: SlackEvent;
+    team_id?: string;
+}
+export interface SlackEvent {
+    type: string;
+    subtype?: string;
+    channel: string;
+    user?: string;
+    text?: string;
+    ts: string;
+    thread_ts?: string;
+    files?: SlackFile[];
+    bot_id?: string;
+    channel_type?: string;
+}
+export interface SlackFile {
+    id: string;
+    name: string;
+    mimetype: string;
+    url_private: string;
+    size: number;
+}
+export interface SlackInteraction {
+    type: string;
+    trigger_id: string;
+    user: {
+        id: string;
+        username: string;
+    };
+    channel?: {
+        id: string;
+    };
+    actions?: Array<{
+        action_id: string;
+        value?: string;
+        block_id?: string;
+    }>;
+    message?: {
+        ts: string;
+        channel?: string;
+    };
+}
+export interface SlackSlashCommand {
+    command: string;
+    text: string;
+    user_id: string;
+    user_name: string;
+    channel_id: string;
+    channel_name: string;
+    trigger_id: string;
+    response_url: string;
+}
+export interface PendingSlackApproval {
+    id: string;
+    channelId: string;
+    threadTs: string;
+    resolve: (choice: string) => void;
+}
+export interface SlackChannelAdapter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(conversationId: string, text: string): Promise<void>;
+    /** Process inbound Slack event. */
+    handleEvent(payload: SlackEventPayload): Promise<{
+        challenge?: string;
+    }>;
+    /** Process slash command. */
+    handleSlashCommand(command: SlackSlashCommand): Promise<string>;
+    /** Process block action (interactive buttons). */
+    handleInteraction(interaction: SlackInteraction): Promise<void>;
+    /** Verify webhook request signature. */
+    verifySignature(timestamp: string, body: string, signature: string): boolean;
+    readonly isRunning: boolean;
+    readonly mode: "socket" | "http";
+}
+export declare function createSlackAdapter(config: SlackConfig): SlackChannelAdapter;