@pinet/slack-bridge 0.1.0

package/dist/broker/client.d.ts

@@ -0,0 +1,167 @@
+import type { PinetReadOptions, PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
+import type { ClientAgentInfo, NormalizedMessageContent, PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput } from "./types.js";
+export interface InboxItem {
+    inboxId: number;
+    message: {
+        id: number;
+        threadId: string;
+        source: string;
+        direction: string;
+        sender: string;
+        body: string;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+    };
+}
+export type { PinetReadMessage, PinetReadOptions, PinetReadResult, PinetUnreadThreadSummary, } from "@pinet/pinet-core/pinet-read-formatting";
+export interface ThreadInfo {
+    threadId: string;
+    source: string;
+    channel: string;
+    ownerAgent: string | null;
+    ownerBinding?: "explicit" | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type AgentInfo = ClientAgentInfo;
+export interface ScheduledWakeupInfo {
+    id: number;
+    threadId: string;
+    fireAt: string;
+}
+export type { PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput, };
+export declare const DEFAULT_SOCKET_PATH: string;
+export declare const REQUEST_TIMEOUT_MS = 5000;
+export declare const RECONNECT_DELAY_MS = 3000;
+export declare const INITIAL_RECONNECT_DELAY_MS = 1000;
+export declare const MAX_RECONNECT_DELAY_MS = 30000;
+export declare const HEARTBEAT_INTERVAL_MS = 5000;
+export declare const HEARTBEAT_METADATA_PROVIDER_TIMEOUT_MS = 2500;
+/** Compute reconnect delay with exponential backoff and jitter. */
+export declare function computeReconnectDelay(attempt: number, random?: number): number;
+export interface AgentBroadcastResult {
+    channel: string;
+    messageIds: number[];
+    recipients: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export type BrokerConnectOpts = {
+    path: string;
+} | {
+    host: string;
+    port: number;
+};
+export interface BrokerClientAuthOptions {
+    meshSecret?: string;
+    meshSecretPath?: string;
+}
+export declare class BrokerClient {
+    private readonly connectOpts;
+    private readonly meshSecret;
+    private readonly meshSecretPath;
+    private socket;
+    private connected;
+    private shuttingDown;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private disconnectHandler;
+    private reconnectHandler;
+    private reconnectFailedHandler;
+    private reconnectAttempt;
+    private registrationSnapshot;
+    private registeredIdentity;
+    private heartbeatMetadataProvider;
+    private heartbeatMetadataInFlight;
+    private nextId;
+    private readonly pending;
+    private buffer;
+    constructor(opts?: string | (BrokerConnectOpts & BrokerClientAuthOptions));
+    connect(): Promise<void>;
+    disconnect(): void;
+    disconnectGracefully(): Promise<void>;
+    isConnected(): boolean;
+    private resolveMeshSecret;
+    private authenticateIfNeeded;
+    register(name: string, emoji: string, metadata?: Record<string, unknown>, stableId?: string): Promise<{
+        agentId: string;
+        name: string;
+        emoji: string;
+        metadata?: Record<string, unknown> | null;
+    }>;
+    unregister(): Promise<void>;
+    heartbeat(metadata?: Record<string, unknown> | null): Promise<void>;
+    setHeartbeatMetadataProvider(provider: (() => Promise<Record<string, unknown> | null | undefined>) | null): void;
+    pollInbox(): Promise<InboxItem[]>;
+    readInbox(options?: PinetReadOptions): Promise<PinetReadResult>;
+    ackMessages(ids: number[]): Promise<void>;
+    send(threadId: string, text: string, metadata?: Record<string, unknown>): Promise<void>;
+    sendMessage(input: {
+        threadId: string;
+        body: string;
+        source?: string;
+        channel?: string;
+        content?: NormalizedMessageContent;
+        blocks?: ReadonlyArray<Record<string, unknown>>;
+        agentName?: string;
+        agentEmoji?: string;
+        agentOwnerToken?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        adapter: string;
+        messageId: number;
+        threadId: string;
+        channel: string;
+        source: string;
+    }>;
+    claimThread(threadId: string, channel?: string, source?: string): Promise<{
+        claimed: boolean;
+    }>;
+    resolveThread(threadTs: string): Promise<string | null>;
+    updateStatus(status: "working" | "idle"): Promise<void>;
+    sendAgentMessage(target: string, body: string, metadata?: Record<string, unknown>): Promise<number>;
+    sendAgentBroadcast(channel: string, body: string): Promise<AgentBroadcastResult>;
+    scheduleWakeup(fireAt: string, body: string): Promise<ScheduledWakeupInfo>;
+    listLanes(options?: PinetLaneListOptions): Promise<PinetLaneInfo[]>;
+    upsertLane(input: PinetLaneUpsertInput): Promise<PinetLaneInfo>;
+    setLaneParticipant(input: PinetLaneParticipantUpsertInput): Promise<PinetLaneParticipantInfo>;
+    acquirePortLease(input: PortLeaseAcquireInput): Promise<PortLeaseInfo>;
+    renewPortLease(input: PortLeaseRenewInput): Promise<PortLeaseInfo>;
+    releasePortLease(input: PortLeaseReleaseInput): Promise<PortLeaseInfo>;
+    getPortLease(leaseId: string): Promise<PortLeaseInfo | null>;
+    listPortLeases(options?: PortLeaseListOptions): Promise<PortLeaseInfo[]>;
+    expirePortLeases(): Promise<PortLeaseInfo[]>;
+    listThreads(): Promise<ThreadInfo[]>;
+    listAgents(includeDisconnected?: boolean): Promise<AgentInfo[]>;
+    invokeAdapterCapability(adapter: string, capability: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Compatibility wrapper for callers that still need direct Slack API access.
+     * The broker RPC boundary remains adapter-neutral; Slack-specific payloads are
+     * interpreted inside the Slack adapter's api.call capability.
+     */
+    slackProxy(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    onDisconnect(handler: () => void): void;
+    onReconnect(handler: () => void): void;
+    onReconnectFailed(handler: (error: Error) => void): void;
+    getReconnectAttempt(): number;
+    getRegisteredIdentity(): {
+        agentId: string;
+        name: string;
+        emoji: string;
+        metadata?: Record<string, unknown> | null;
+    } | null;
+    private request;
+    private onData;
+    private handleResponse;
+    private scheduleReconnect;
+    private connectSocket;
+    private performRegister;
+    private reconnectOnce;
+    private startHeartbeat;
+    private readHeartbeatMetadata;
+    private runHeartbeatTick;
+    private stopHeartbeat;
+    private rejectAllPending;
+}