@questionbase/deskfree 0.3.0-alpha.7 → 0.3.0-alpha.9

package/dist/index.d.ts

@@ -1,12 +1,727 @@
-import type { OpenClawPluginApi } from './types';
-export { DeskFreeClient, DeskFreeError } from './client';
-export { reportError } from './error-reporter';
-export { OfflineQueue } from './offline-queue';
-export type * from './types';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Minimal type definitions for the OpenClaw plugin API.
+ * These mirror the actual OpenClaw types but are defined inline
+ * to avoid a hard dependency on the openclaw package at build time.
+ * At runtime, the real types are provided by OpenClaw.
+ */
+
+interface AnyAgentTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (id: string, params: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }>;
+    optional?: boolean;
+}
+interface OpenClawPluginToolContext {
+    config?: unknown;
+    messageChannel?: unknown;
+    agentAccountId?: string;
+    sandboxed?: boolean;
+}
+type OpenClawPluginToolFactory = (ctx: OpenClawPluginToolContext) => AnyAgentTool | AnyAgentTool[] | null | undefined;
+interface OpenClawPluginToolOptions {
+    optional?: boolean;
+}
+interface OpenClawConfig {
+    channels?: {
+        deskfree?: DeskFreeChannelConfig;
+        [key: string]: unknown;
+    };
+    plugins?: {
+        entries?: {
+            [pluginId: string]: {
+                enabled?: boolean;
+                [key: string]: unknown;
+            };
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface OpenClawPluginApi {
+    runtime: PluginRuntime;
+    config: OpenClawConfig;
+    pluginConfig: Record<string, unknown>;
+    logger: PluginLogger;
+    registerChannel(registration: {
+        plugin: ChannelPlugin;
+    }): void;
+    registerHttpRoute(params: {
+        path: string;
+        handler: (req: IncomingMessage, res: ServerResponse) => Promise<void> | void;
+    }): void;
+    registerTool(tool: AnyAgentTool | OpenClawPluginToolFactory, opts?: OpenClawPluginToolOptions): void;
+    registerHook(events: string | string[], handler: (event: Record<string, unknown>) => Promise<unknown> | unknown, opts?: {
+        priority?: number;
+    }): void;
+    on<K extends PluginHookName>(hookName: K, handler: PluginHookHandlerMap[K], opts?: {
+        priority?: number;
+    }): void;
+}
+type PluginHookName = 'before_agent_start' | 'llm_input' | 'llm_output' | 'agent_end' | 'before_compaction' | 'after_compaction' | 'before_reset' | 'message_received' | 'message_sending' | 'message_sent' | 'before_tool_call' | 'after_tool_call' | 'tool_result_persist' | 'session_start' | 'session_end' | 'gateway_start' | 'gateway_stop';
+interface PluginHookAgentContext {
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    messageProvider?: string;
+}
+interface PluginHookBeforeAgentStartEvent {
+    prompt: string;
+    messages?: unknown[];
+}
+interface PluginHookBeforeAgentStartResult {
+    systemPrompt?: string;
+    prependContext?: string;
+}
+type PluginHookHandlerMap = {
+    before_agent_start: (event: PluginHookBeforeAgentStartEvent, ctx: PluginHookAgentContext) => Promise<PluginHookBeforeAgentStartResult | void> | PluginHookBeforeAgentStartResult | void;
+    llm_input: (event: Record<string, unknown>, ctx: PluginHookAgentContext) => Promise<void> | void;
+    llm_output: (event: Record<string, unknown>, ctx: PluginHookAgentContext) => Promise<void> | void;
+    agent_end: (event: Record<string, unknown>, ctx: PluginHookAgentContext) => Promise<void> | void;
+    before_compaction: (event: Record<string, unknown>, ctx: PluginHookAgentContext) => Promise<void> | void;
+    after_compaction: (event: Record<string, unknown>, ctx: PluginHookAgentContext) => Promise<void> | void;
+    before_reset: (event: Record<string, unknown>, ctx: PluginHookAgentContext) => Promise<void> | void;
+    message_received: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+    message_sending: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
+    message_sent: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+    before_tool_call: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
+    after_tool_call: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+    tool_result_persist: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Record<string, unknown> | void;
+    session_start: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+    session_end: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+    gateway_start: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+    gateway_stop: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<void> | void;
+};
+interface PluginRuntime {
+    version: string;
+    config: {
+        loadConfig(): OpenClawConfig;
+        writeConfigFile(cfg: OpenClawConfig): Promise<void>;
+    };
+    channel: {
+        reply: {
+            finalizeInboundContext<T extends Record<string, unknown>>(ctx: T): T & FinalizedMsgContext;
+            dispatchReplyFromConfig(params: {
+                ctx: FinalizedMsgContext;
+                cfg: OpenClawConfig;
+                dispatcher: ReplyDispatcher;
+                replyOptions?: Record<string, unknown>;
+            }): Promise<{
+                queuedFinal: boolean;
+            }>;
+            createReplyDispatcherWithTyping(params: {
+                channel: string;
+                accountId: string;
+                deliver: (payload: {
+                    text?: string;
+                    body?: string;
+                }) => Promise<void>;
+                [key: string]: unknown;
+            }): {
+                dispatcher: ReplyDispatcher;
+                replyOptions: Record<string, unknown>;
+                markDispatchIdle: () => void;
+            };
+        };
+        text: {
+            chunkMarkdownText(text: string, limit: number): string[];
+        };
+    };
+    logging: {
+        createLogger(name: string): PluginLogger;
+    };
+    state: {
+        resolveStateDir(): string;
+    };
+}
+interface FinalizedMsgContext {
+    Body: string;
+    RawBody?: string;
+    ChatType: string;
+    Provider: string;
+    Surface: string;
+    From: string;
+    To: string;
+    MessageSid: string;
+    Timestamp?: string;
+    BodyForAgent?: string;
+    [key: string]: unknown;
+}
+interface ReplyDispatcher {
+    send(reply: unknown): Promise<void>;
+    getQueuedCounts(): unknown;
+}
+interface PluginLogger {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    debug(msg: string): void;
+}
+interface ChannelMessagingTargetResolver {
+    hint?: string;
+    looksLikeId?(raw: string, normalized?: string): boolean;
+}
+interface ChannelMessagingAdapter {
+    normalizeTarget?(raw: string): string | undefined;
+    targetResolver?: ChannelMessagingTargetResolver;
+}
+interface ChannelPlugin {
+    id: string;
+    meta: ChannelMeta;
+    capabilities: ChannelCapabilities;
+    config: ChannelConfigAdapter;
+    outbound?: ChannelOutboundAdapter;
+    gateway?: ChannelGatewayAdapter;
+    setup?: ChannelSetupAdapter;
+    security?: ChannelSecurityAdapter;
+    messaging?: ChannelMessagingAdapter;
+    onboarding?: ChannelOnboardingAdapter;
+    status?: ChannelStatusAdapter;
+}
+interface ChannelMeta {
+    name: string;
+    icon?: string;
+    description?: string;
+}
+interface ChannelCapabilities {
+    text: boolean;
+    media: boolean;
+    reactions: boolean;
+    threads: boolean;
+    editing: boolean;
+}
+interface ChannelConfigAdapter {
+    listAccountIds(cfg: OpenClawConfig): string[];
+    resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDeskFreeAccount;
+    isConfigured?(account: ResolvedDeskFreeAccount, cfg?: OpenClawConfig): boolean;
+    isEnabled?(account: ResolvedDeskFreeAccount, cfg?: OpenClawConfig): boolean;
+    describeAccount?(account: ResolvedDeskFreeAccount, cfg?: OpenClawConfig): ChannelAccountSnapshot;
+}
+interface ChannelOutboundAdapter {
+    deliveryMode: 'direct' | 'gateway' | 'hybrid';
+    resolveTarget?(target: string, ctx: {
+        cfg: OpenClawConfig;
+        accountId?: string | null;
+    }): {
+        to: string;
+    } | null;
+    sendText?(ctx: ChannelOutboundContext): Promise<OutboundDeliveryResult>;
+    textChunkLimit?: number;
+    chunkerMode?: 'text' | 'markdown';
+}
+interface ChannelGatewayAdapter {
+    startAccount?(ctx: ChannelGatewayContext): Promise<unknown>;
+    stopAccount?(ctx: ChannelGatewayContext): Promise<void>;
+    logoutAccount?(ctx: ChannelLogoutContext): Promise<ChannelLogoutResult>;
+}
+interface ChannelGatewayContext {
+    cfg: OpenClawConfig;
+    accountId: string;
+    account: ResolvedDeskFreeAccount;
+    runtime: PluginRuntime;
+    abortSignal: AbortSignal;
+    log?: PluginLogger;
+    getStatus(): ChannelAccountSnapshot;
+    setStatus(next: Partial<ChannelAccountSnapshot>): void;
+}
+interface ChannelSetupAdapter {
+    applyAccountConfig(params: {
+        cfg: OpenClawConfig;
+        accountId: string;
+        input: Record<string, string>;
+    }): OpenClawConfig;
+    validateInput?(params: {
+        cfg: OpenClawConfig;
+        accountId: string;
+        input: Record<string, string>;
+    }): string | null;
+}
+interface ChannelSecurityDmPolicy {
+    policy: string;
+    allowFrom?: Array<string | number> | null;
+    policyPath?: string;
+    allowFromPath: string;
+    approveHint: string;
+    normalizeEntry?: (raw: string) => string;
+}
+interface ChannelSecurityAdapter {
+    resolveDmPolicy?(ctx: {
+        cfg: OpenClawConfig;
+        accountId?: string | null;
+        account: ResolvedDeskFreeAccount;
+    }): ChannelSecurityDmPolicy | null;
+    collectWarnings?(ctx: {
+        cfg: OpenClawConfig;
+        accountId?: string | null;
+        account: ResolvedDeskFreeAccount;
+    }): Promise<string[]> | string[];
+}
+interface ChannelOutboundContext {
+    cfg: OpenClawConfig;
+    to: string;
+    text: string;
+    threadId?: string | number | null;
+    replyToId?: string | null;
+    accountId?: string | null;
+}
+interface OutboundDeliveryResult {
+    channel: string;
+    success: boolean;
+    threadId?: string;
+}
+interface ChannelAccountSnapshot {
+    accountId?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    running?: boolean;
+    lastStartAt?: number;
+    lastStopAt?: number;
+    lastError?: string;
+    probe?: ChannelProbeResult;
+}
+interface ResolvedDeskFreeAccount {
+    accountId: string;
+    botToken: string;
+    apiUrl: string;
+    wsUrl: string;
+    userId: string;
+    enabled: boolean;
+    botName?: string;
+    humanName?: string;
+}
+interface DeskFreeChannelConfig {
+    enabled?: boolean;
+    botToken: string;
+    apiUrl: string;
+    wsUrl: string;
+    userId: string;
+    botName?: string;
+    humanName?: string;
+    accounts?: Record<string, Omit<DeskFreeChannelConfig, 'accounts'>>;
+}
+interface ChatMessageAttachment {
+    name: string;
+    contentType: string;
+    size: number;
+    url: string;
+}
+interface ChatMessage {
+    messageId: string;
+    botId: string;
+    humanId: string;
+    authorType: 'bot' | 'user';
+    content: string;
+    attachments?: ChatMessageAttachment[];
+    taskId?: string | null;
+    createdAt: string;
+    userName?: string | null;
+    botName?: string | null;
+}
+interface MessagesResponse {
+    items: ChatMessage[];
+    cursor: string | null;
+    hasMore: boolean;
+}
+interface WsTicketResponse {
+    ticket: string;
+    wsUrl: string;
+    expiresAt: string;
+}
+interface WizardPrompter {
+    text(params: {
+        message: string;
+        initialValue?: string;
+        placeholder?: string;
+        validate?: (value: string) => string | undefined;
+    }): Promise<string>;
+    confirm(params: {
+        message: string;
+        initialValue?: boolean;
+    }): Promise<boolean>;
+    note(message: string, title?: string): Promise<void>;
+}
+interface ChannelOnboardingStatus {
+    channel: string;
+    configured: boolean;
+    statusLines: string[];
+    selectionHint?: string;
+    quickstartScore?: number;
+}
+interface ChannelOnboardingResult {
+    cfg: OpenClawConfig;
+    accountId?: string;
+}
+interface ChannelOnboardingAdapter {
+    channel: string;
+    getStatus(ctx: {
+        cfg: OpenClawConfig;
+    }): Promise<ChannelOnboardingStatus>;
+    configure(ctx: {
+        cfg: OpenClawConfig;
+        runtime: PluginRuntime;
+        prompter: WizardPrompter;
+        accountOverrides: Record<string, string>;
+        shouldPromptAccountIds: boolean;
+        forceAllowFrom: boolean;
+    }): Promise<ChannelOnboardingResult>;
+    disable?(cfg: OpenClawConfig): OpenClawConfig;
+}
+interface ChannelProbeResult {
+    ok: boolean;
+    error?: string;
+}
+interface ChannelStatusIssue {
+    channel: string;
+    accountId: string;
+    kind: 'config' | 'auth' | 'runtime';
+    message: string;
+    fix?: string;
+}
+interface ChannelStatusAdapter {
+    probeAccount?(params: {
+        account: ResolvedDeskFreeAccount;
+        timeoutMs: number;
+        cfg: OpenClawConfig;
+    }): Promise<ChannelProbeResult>;
+    buildAccountSnapshot?(params: {
+        account: ResolvedDeskFreeAccount;
+        cfg: OpenClawConfig;
+        runtime?: ChannelAccountSnapshot;
+        probe?: ChannelProbeResult;
+    }): ChannelAccountSnapshot;
+    collectStatusIssues?(accounts: ChannelAccountSnapshot[]): ChannelStatusIssue[];
+}
+interface ChannelLogoutContext {
+    cfg: OpenClawConfig;
+    accountId: string;
+    account: ResolvedDeskFreeAccount;
+    runtime: PluginRuntime;
+    log?: PluginLogger;
+}
+interface ChannelLogoutResult {
+    cleared: boolean;
+    loggedOut?: boolean;
+    [key: string]: unknown;
+}
+interface WsNotification {
+    action: 'notify';
+    hint: string;
+}
+interface Goal {
+    goalId: string;
+    botId: string;
+    createdById: string;
+    title: string;
+    description?: string | null;
+    status: 'active' | 'paused' | 'completed' | 'archived';
+    createdAt: string;
+    updatedAt: string;
+}
+interface Task {
+    taskId: string;
+    title: string;
+    status: 'ready_for_bot' | 'working_on_it' | 'waiting_for_human' | 'done';
+    instructions?: string;
+    createdAt: string;
+    updatedAt: string;
+    botId?: string | null;
+    createdById: string;
+    reason?: string | null;
+    deliverable?: string | null;
+}
+interface TaskMessage {
+    messageId: string;
+    authorType: 'bot' | 'user';
+    content: string;
+    attachments: ChatMessageAttachment[];
+    createdAt: string;
+    userName?: string | null;
+}
+interface TaskWithContext extends Task {
+    instructions: string;
+    deliverable: string;
+    messages: TaskMessage[];
+}
+/**
+ * Response from the tasks.create bot endpoint.
+ *
+ * The backend mutation (`trpc.bot.tasks.create`) returns the Task object
+ * directly (not wrapped in `{ task: ... }`), unlike `goals.create` which
+ * returns `{ goal: Goal }`.
+ */
+type CreateTaskResponse = Task;
+interface CompleteTaskInput {
+    taskId: string;
+    outcome: 'done' | 'blocked';
+}
+interface WorkspaceStateTask {
+    taskId: string;
+    title: string;
+    status: 'ready_for_bot' | 'working_on_it' | 'waiting_for_human' | 'done';
+    instructions?: string | null;
+    deliverable?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface WorkspaceStateGoal {
+    goalId: string;
+    title: string;
+    description?: string | null;
+    status: 'active' | 'paused' | 'completed' | 'archived';
+    tasks: WorkspaceStateTask[];
+}
+interface WorkspaceState {
+    goals: WorkspaceStateGoal[];
+    unlinkedTasks: WorkspaceStateTask[];
+    recentlyDone: WorkspaceStateTask[];
+}
+
+/** Enhanced error class for DeskFree API errors with user-friendly messages */
+declare class DeskFreeError extends Error {
+    readonly type: 'network' | 'auth' | 'server' | 'client' | 'timeout' | 'invalid_response';
+    readonly statusCode?: number;
+    readonly userMessage: string;
+    readonly procedure: string;
+    constructor(type: DeskFreeError['type'], procedure: string, message: string, userMessage: string, statusCode?: number);
+    static fromResponse(response: Response, procedure: string, responseText: string): DeskFreeError;
+    static timeout(procedure: string, timeoutMs: number): DeskFreeError;
+    static invalidResponse(procedure: string): DeskFreeError;
+    static network(procedure: string, originalError: Error): DeskFreeError;
+}
+declare class DeskFreeClient {
+    private botToken;
+    private apiUrl;
+    private requestTimeoutMs;
+    constructor(botToken: string, apiUrl: string, options?: {
+        requestTimeoutMs?: number;
+    });
+    private request;
+    /**
+     * Validates that a string parameter is non-empty.
+     * Catches invalid inputs before they hit the network.
+     */
+    private requireNonEmpty;
+    /**
+     * Send a typing indicator to the DeskFree conversation.
+     *
+     * @param input - Optional parameters including taskId to scope the indicator
+     */
+    typing(input?: {
+        taskId?: string;
+        clear?: boolean;
+    }): Promise<void>;
+    /**
+     * Update an existing bot message content (for streaming).
+     *
+     * @param input - messageId, new content, and streaming flag
+     */
+    updateMessage(input: {
+        messageId: string;
+        content: string;
+        streaming?: boolean;
+    }): Promise<{
+        messageId: string;
+        content: string;
+    }>;
+    /**
+     * Send a text message (with optional attachments) to a DeskFree conversation.
+     *
+     * @param input - Message content, optional userId, taskId, and attachments
+     */
+    sendMessage(input: {
+        userId?: string;
+        content: string;
+        taskId?: string;
+        attachments?: Array<{
+            s3Key: string;
+            name: string;
+            contentType: string;
+            size: number;
+        }>;
+    }): Promise<{
+        messageId: string;
+        content: string;
+    }>;
+    /** Fetch paginated message history for a conversation. */
+    listMessages(input: {
+        userId?: string;
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<MessagesResponse>;
+    /** Obtain a one-time WebSocket authentication ticket for real-time notifications. */
+    getWsTicket(): Promise<WsTicketResponse>;
+    /** Create a new goal. */
+    createGoal(input: {
+        title: string;
+        description?: string;
+    }): Promise<{
+        goal: Goal;
+    }>;
+    /** Update a goal's status, title, or description. */
+    updateGoal(input: {
+        goalId: string;
+        title?: string;
+        description?: string;
+        status?: string;
+    }): Promise<Goal>;
+    /** Create a new task, optionally with a recurring schedule. */
+    createTask(input: {
+        title: string;
+        instructions?: string;
+        goalId?: string;
+        isRecurring?: boolean;
+        recurringSchedule?: {
+            frequency: 'daily' | 'weekly' | 'biweekly' | 'monthly';
+            dayOfWeek?: number;
+            dayOfMonth?: number;
+            time: string;
+            timezone?: string;
+        };
+    }): Promise<CreateTaskResponse>;
+    /** Claim a task so the bot can begin working on it. Returns enriched context. */
+    claimTask(input: {
+        taskId: string;
+    }): Promise<TaskWithContext>;
+    /** Update the deliverable (markdown content) for a task. */
+    updateDeliverable(input: {
+        taskId: string;
+        deliverable: string;
+    }): Promise<void>;
+    /** Send an agent status update to DeskFree. */
+    statusUpdate(input: {
+        status: 'idle' | 'working' | 'responding';
+        activeSubAgents: Array<{
+            label: string;
+            status: 'running' | 'completed' | 'failed';
+            startedAt: string;
+            completedAt?: string;
+            tokenUsage?: number;
+            task?: string;
+        }>;
+        model?: string;
+        lastActivity?: string;
+        pluginVersion?: string;
+        openclawVersion?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /** Report error log entries to the backend for CloudWatch/Slack visibility. */
+    reportError(input: {
+        errors: Array<{
+            message: string;
+            level: 'warn' | 'error' | 'fatal';
+            timestamp: string;
+            metadata?: Record<string, unknown>;
+        }>;
+    }): Promise<{
+        accepted: number;
+    }>;
+    /** Get short-lived AWS credentials for S3 workspace access. */
+    workspaceCredentials(): Promise<{
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken: string;
+        expiration: Date;
+        s3Uri: string;
+        region: string;
+    }>;
+    /** Notify DeskFree that workspace files have changed locally. */
+    workspaceRead(input: {
+        path: string;
+    }): Promise<{
+        path: string;
+        content: string;
+        lastModified: string;
+    }>;
+    /** Get full workspace snapshot — goals with tasks, unlinked tasks, recently done. */
+    getState(): Promise<WorkspaceState>;
+    /** Report token usage for a task. Atomically increments rollup columns. */
+    reportUsage(input: {
+        taskId: string;
+        inputTokens: number;
+        outputTokens: number;
+        thinkingTokens: number;
+        model: string;
+        estimatedCost: number;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /** Complete a task with an outcome. Moves task to waiting_for_human. */
+    completeTask(input: CompleteTaskInput): Promise<Task & {
+        outcome: 'done' | 'blocked';
+    }>;
+    /**
+     * Lightweight health check that verifies connectivity and authentication.
+     *
+     * @param timeoutMs - Maximum time to wait for the probe response
+     * @returns Probe result indicating success or a descriptive error
+     */
+    probe(timeoutMs: number): Promise<ChannelProbeResult>;
+}
+
+/**
+ * Convenience: report an error if the reporter is initialized.
+ * No-op if called before initErrorReporter(). Never throws.
+ */
+declare function reportError(level: 'warn' | 'error' | 'fatal', message: string, metadata?: Record<string, unknown>): void;
+
+/**
+ * Offline queue for failed API requests.
+ *
+ * When the DeskFree API is unreachable (network errors, timeouts),
+ * outbound requests are queued in memory and retried with exponential
+ * backoff when connectivity is restored.
+ */
+
+/** A queued request that can be retried. */
+interface QueuedRequest {
+    id: string;
+    /** Human-readable description for logging. */
+    label: string;
+    /** The function to execute. Must be idempotent for safe retries. */
+    execute: () => Promise<void>;
+    /** Number of retry attempts so far. */
+    attempts: number;
+    /** Timestamp when the request was first queued. */
+    queuedAt: number;
+}
+declare class OfflineQueue {
+    private queue;
+    private processing;
+    private retryTimer;
+    private log;
+    constructor(log: PluginLogger);
+    /** Number of requests currently queued. */
+    get size(): number;
+    /**
+     * Enqueue a failed request for later retry.
+     * Returns false if the queue is full.
+     */
+    enqueue(request: Omit<QueuedRequest, 'attempts' | 'queuedAt'>): boolean;
+    /**
+     * Attempt to flush all queued requests.
+     * Called when connectivity is restored (e.g., WebSocket reconnect).
+     */
+    flush(): Promise<void>;
+    /** Clear all queued requests. */
+    clear(): void;
+    /** Stop the retry timer (for cleanup). */
+    destroy(): void;
+    private scheduleRetry;
+}
+
 declare const plugin: {
     id: string;
     name: string;
     register(api: OpenClawPluginApi): void;
 };
-export default plugin;
-//# sourceMappingURL=index.d.ts.map
+
+export { type AnyAgentTool, type ChannelAccountSnapshot, type ChannelCapabilities, type ChannelConfigAdapter, type ChannelGatewayAdapter, type ChannelGatewayContext, type ChannelLogoutContext, type ChannelLogoutResult, type ChannelMessagingAdapter, type ChannelMessagingTargetResolver, type ChannelMeta, type ChannelOnboardingAdapter, type ChannelOnboardingResult, type ChannelOnboardingStatus, type ChannelOutboundAdapter, type ChannelOutboundContext, type ChannelPlugin, type ChannelProbeResult, type ChannelSecurityAdapter, type ChannelSecurityDmPolicy, type ChannelSetupAdapter, type ChannelStatusAdapter, type ChannelStatusIssue, type ChatMessage, type ChatMessageAttachment, type CompleteTaskInput, type CreateTaskResponse, type DeskFreeChannelConfig, DeskFreeClient, DeskFreeError, type FinalizedMsgContext, type Goal, type MessagesResponse, OfflineQueue, type OpenClawConfig, type OpenClawPluginApi, type OpenClawPluginToolContext, type OpenClawPluginToolFactory, type OpenClawPluginToolOptions, type OutboundDeliveryResult, type PluginHookAgentContext, type PluginHookBeforeAgentStartEvent, type PluginHookBeforeAgentStartResult, type PluginHookHandlerMap, type PluginHookName, type PluginLogger, type PluginRuntime, type ReplyDispatcher, type ResolvedDeskFreeAccount, type Task, type TaskMessage, type TaskWithContext, type WizardPrompter, type WorkspaceState, type WorkspaceStateGoal, type WorkspaceStateTask, type WsNotification, type WsTicketResponse, plugin as default, reportError };