@band-ai/sdk 0.1.2

package/dist/schemas-BpEBkq5V.d.cts

@@ -0,0 +1,592 @@
+import { h as AgentToolsCapabilities, g as PlatformMessageLike, A as AdapterToolsProtocol, e as Preprocessor, F as FrameworkAdapter, i as PreprocessorContext } from './protocols-CInhtFpA.cjs';
+import { f as PlatformEvent, P as PlatformMessage, e as ConversationContext, S as SessionConfig, c as ContactEventConfig, A as AgentConfig, C as ContactEvent, a as AgentInput } from './types-CovcHpYf.cjs';
+import { M as MetadataMap, P as ParticipantRecord } from './dtos-DUpbIu8k.cjs';
+import { L as Logger } from './logger-CABQOnlR.cjs';
+import { T as ThenvoiLinkRestApi, b as RestRequestOptions, P as PaginatedResponse, e as AgentToolsRestApi } from './types-CSHFipIc.cjs';
+import { P as PaginationOptions } from './pagination-BPiys10t.cjs';
+
+interface TopicHandlers {
+    [event: string]: (payload: Record<string, unknown>) => Promise<void> | void;
+}
+interface StreamingTransport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    join(topic: string, handlers: TopicHandlers): Promise<void>;
+    leave(topic: string): Promise<void>;
+    runForever(signal: AbortSignal): Promise<void>;
+    isConnected(): boolean;
+}
+
+interface ThenvoiLinkOptions {
+    agentId: string;
+    apiKey: string;
+    wsUrl?: string;
+    restUrl?: string;
+    restApi?: ThenvoiLinkRestApi;
+    transport?: StreamingTransport;
+    logger?: Logger;
+    capabilities?: Partial<AgentToolsCapabilities>;
+}
+interface MessageMarkOptions {
+    bestEffort?: boolean;
+}
+declare class ThenvoiLink implements AsyncIterable<PlatformEvent> {
+    readonly agentId: string;
+    private readonly apiKey;
+    readonly wsUrl: string;
+    readonly restUrl: string;
+    readonly rest: ThenvoiLinkRestApi;
+    readonly capabilities: AgentToolsCapabilities;
+    private readonly logger;
+    private readonly transport;
+    private readonly subscribedRooms;
+    private readonly eventQueue;
+    private readonly waiters;
+    private connected;
+    constructor(options: ThenvoiLinkOptions);
+    isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    runForever(signal: AbortSignal): Promise<void>;
+    queueEvent(event: PlatformEvent): void;
+    subscribeAgentRooms(): Promise<void>;
+    subscribeRoom(roomId: string): Promise<void>;
+    unsubscribeRoom(roomId: string): Promise<void>;
+    subscribeAgentContacts(): Promise<void>;
+    unsubscribeAgentContacts(): Promise<void>;
+    nextEvent(signal?: AbortSignal): Promise<PlatformEvent | null>;
+    [Symbol.asyncIterator](): AsyncIterator<PlatformEvent>;
+    markProcessing(roomId: string, messageId: string, options?: MessageMarkOptions): Promise<void>;
+    markProcessed(roomId: string, messageId: string, options?: MessageMarkOptions): Promise<void>;
+    markFailed(roomId: string, messageId: string, error: string, options?: MessageMarkOptions): Promise<void>;
+    private markMessageStatus;
+    getNextMessage(roomId: string): Promise<PlatformMessageLike | null>;
+    getStaleProcessingMessages(roomId: string): Promise<PlatformMessageLike[]>;
+    listChats(request: {
+        page: number;
+        pageSize: number;
+    }, requestOptions?: RestRequestOptions): Promise<PaginatedResponse>;
+    listAllChats(options?: PaginationOptions, requestOptions?: RestRequestOptions): Promise<MetadataMap[]>;
+    private emit;
+}
+
+declare class MessageRetryTracker {
+    private readonly maxRetriesValue;
+    private readonly maxTracked;
+    private attempts;
+    private failed;
+    constructor(maxRetries?: number, maxTracked?: number);
+    get maxRetries(): number;
+    isPermanentlyFailed(messageId: string): boolean;
+    recordAttempt(messageId: string): [number, boolean];
+    markSuccess(messageId: string): void;
+    markPermanentlyFailed(messageId: string): void;
+    private evictMapIfNeeded;
+    private evictSetIfNeeded;
+}
+
+type ExecutionState = "starting" | "idle" | "processing";
+interface ExecutionContextLink {
+    rest: AgentToolsRestApi;
+    capabilities?: Partial<AgentToolsCapabilities>;
+}
+interface ExecutionContextOptions {
+    roomId: string;
+    link: ExecutionContextLink;
+    maxContextMessages: number;
+    maxMessageRetries?: number;
+    enableContextCache?: boolean;
+    contextCacheTtlSeconds?: number;
+    enableContextHydration?: boolean;
+}
+declare class ExecutionContext {
+    readonly roomId: string;
+    readonly link: ExecutionContextLink;
+    private readonly maxContextMessages;
+    private readonly enableContextCache;
+    private readonly contextCacheTtlMs;
+    private readonly enableContextHydration;
+    private readonly history;
+    private messageIds;
+    private readonly dedupCache;
+    private participants;
+    private readonly tools;
+    private readonly adapterTools;
+    private participantsMessage;
+    private lastSentParticipantIds;
+    private contactsMessage;
+    private contextCache;
+    private contextCacheExpiresAt;
+    private _state;
+    private readonly retryTrackerInstance;
+    private _llmInitialized;
+    private readonly _pendingSystemMessages;
+    constructor(options: ExecutionContextOptions);
+    get state(): ExecutionState;
+    setState(state: ExecutionState): void;
+    getRetryTracker(): MessageRetryTracker;
+    get isLlmInitialized(): boolean;
+    markLlmInitialized(): void;
+    injectSystemMessage(message: string): void;
+    consumeSystemMessages(): string[];
+    getTools(): AdapterToolsProtocol;
+    hasMessage(messageId: string): boolean;
+    recordMessage(message: PlatformMessage): void;
+    getRawHistory(): MetadataMap[];
+    setParticipants(participants: ParticipantRecord[]): void;
+    addParticipant(participant: ParticipantRecord): void;
+    removeParticipant(participantId: string): void;
+    setContactsMessage(message: string | null): void;
+    consumeParticipantsMessage(): string | null;
+    consumeContactsMessage(): string | null;
+    getHydratedHistory(excludeMessageId?: string): Promise<MetadataMap[]>;
+    hydrateContext(forceRefresh?: boolean): Promise<ConversationContext>;
+    private replaceParticipants;
+    private buildLocalContext;
+    private loadParticipants;
+    private loadHydratedMessages;
+    private updateCachedParticipants;
+    private isCacheExpired;
+    private nextCacheExpiry;
+    private toHistoryEntry;
+    private rebuildMessageIds;
+    private trackDedup;
+}
+
+interface PlatformRuntimeOptions {
+    agentId: string;
+    apiKey: string;
+    wsUrl?: string;
+    restUrl?: string;
+    link?: ThenvoiLink;
+    linkOptions?: Omit<ThenvoiLinkOptions, "agentId" | "apiKey">;
+    preprocessor?: Preprocessor<PlatformEvent>;
+    sessionConfig?: SessionConfig;
+    contactConfig?: ContactEventConfig;
+    agentConfig?: AgentConfig;
+    logger?: Logger;
+    onParticipantAdded?: (roomId: string, participant: ParticipantRecord) => Promise<void> | void;
+    onParticipantRemoved?: (roomId: string, participantId: string) => Promise<void> | void;
+    roomFilter?: (room: MetadataMap) => boolean;
+    contextFactory?: (roomId: string, defaults: ExecutionContextOptions) => ExecutionContext;
+    identity?: {
+        name: string;
+        description?: string | null;
+    };
+}
+declare class PlatformRuntime {
+    private readonly _agentId;
+    private readonly _apiKey;
+    private readonly _wsUrl?;
+    private readonly _restUrl?;
+    private readonly preprocessor;
+    private readonly sessionConfig?;
+    private readonly contactConfig?;
+    private readonly agentConfig?;
+    private readonly linkOptions?;
+    private readonly configuredIdentity?;
+    private readonly logger;
+    private readonly _onParticipantAdded?;
+    private readonly _onParticipantRemoved?;
+    private readonly _roomFilter?;
+    private readonly _contextFactory?;
+    private linkInstance?;
+    private initPromise;
+    private runtime?;
+    private contactHandler?;
+    private activeAdapter?;
+    private stopping;
+    private _agentName;
+    private _agentDescription;
+    private contactsSubscribed;
+    constructor(options: PlatformRuntimeOptions);
+    get link(): ThenvoiLink;
+    get name(): string;
+    get agentId(): string;
+    get description(): string;
+    get contactConfiguration(): ContactEventConfig | undefined;
+    get isContactsSubscribed(): boolean;
+    initialize(): Promise<void>;
+    private doInitialize;
+    start(adapter: FrameworkAdapter): Promise<void>;
+    stop(timeoutMs?: number): Promise<boolean>;
+    runForever(): Promise<void>;
+    bootstrapRoomMessage(roomId: string, message: PlatformMessage): Promise<void>;
+    resetRoomSession(roomId: string, timeoutMs?: number): Promise<boolean>;
+    private executeAdapter;
+    private handleContactEvent;
+}
+
+interface AgentRuntimeOptions {
+    link: ThenvoiLink;
+    agentId: string;
+    onExecute: (context: ExecutionContext, event: PlatformEvent) => Promise<void>;
+    onSessionCleanup?: (roomId: string) => Promise<void>;
+    onRoomJoined?: (roomId: string, payload: MetadataMap) => Promise<void> | void;
+    onRoomLeft?: (roomId: string) => Promise<void> | void;
+    onContactEvent?: (event: ContactEvent) => Promise<void>;
+    onParticipantAdded?: (roomId: string, participant: ParticipantRecord) => Promise<void> | void;
+    onParticipantRemoved?: (roomId: string, participantId: string) => Promise<void> | void;
+    onError?: (error: unknown, event: PlatformEvent) => void;
+    roomFilter?: (room: MetadataMap) => boolean;
+    contextFactory?: (roomId: string, defaults: ExecutionContextOptions) => ExecutionContext;
+    sessionConfig?: SessionConfig;
+    agentConfig?: AgentConfig;
+    logger?: Logger;
+}
+declare class AgentRuntime {
+    private readonly link;
+    private readonly agentId;
+    private readonly onExecute;
+    private readonly onSessionCleanup;
+    private readonly onRoomJoined?;
+    private readonly onRoomLeft?;
+    private readonly onContactEvent?;
+    private readonly onParticipantAdded?;
+    private readonly onParticipantRemoved?;
+    private readonly onError?;
+    private readonly roomFilter?;
+    private readonly contextFactory?;
+    private readonly sessionConfig;
+    private readonly autoSubscribeExistingRooms;
+    private readonly subscribedRooms;
+    private readonly contexts;
+    private readonly executions;
+    private readonly executionWatchers;
+    private readonly logger;
+    private running;
+    private stopping;
+    private stopController;
+    private consumeTask;
+    private fatalError;
+    constructor(options: AgentRuntimeOptions);
+    start(): Promise<void>;
+    private handleStartFailure;
+    stop(timeoutMs?: number): Promise<boolean>;
+    getContext(roomId: string): ExecutionContext | undefined;
+    waitUntilStopped(): Promise<void>;
+    getContexts(): ExecutionContext[];
+    private consumeLoop;
+    private handleEvent;
+    enqueueEvent(roomId: string, event: PlatformEvent): Promise<void>;
+    bootstrapRoomMessage(roomId: string, message: PlatformMessage): Promise<void>;
+    resetRoomSession(roomId: string, timeoutMs?: number): Promise<boolean>;
+    private getOrCreateExecution;
+    getOrCreateContext(roomId: string): ExecutionContext;
+    private subscribeExistingRooms;
+    private leaveTrackedRoom;
+    private failRuntime;
+    private notifyOnError;
+}
+
+declare class DefaultPreprocessor implements Preprocessor<PlatformEvent> {
+    process(context: PreprocessorContext, event: PlatformEvent, agentId: string): Promise<AgentInput | null>;
+}
+
+declare const TOOL_MODELS: {
+    readonly thenvoi_send_message: {
+        readonly description: string;
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "The message content to send.";
+            };
+            readonly mentions: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly minItems: 1;
+                readonly description: string;
+            };
+        };
+        readonly required: readonly ["content", "mentions"];
+    };
+    readonly thenvoi_send_event: {
+        readonly description: string;
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "Human-readable event content.";
+            };
+            readonly message_type: {
+                readonly type: "string";
+                readonly enum: readonly ["tool_call", "tool_result", "thought", "error", "task"];
+                readonly description: "Type of event.";
+            };
+            readonly metadata: {
+                readonly type: "object";
+                readonly description: "Optional structured data for the event.";
+            };
+        };
+        readonly required: readonly ["content", "message_type"];
+    };
+    readonly thenvoi_add_participant: {
+        readonly description: string;
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of participant to add (must match a name from thenvoi_lookup_peers).";
+            };
+            readonly role: {
+                readonly type: "string";
+                readonly enum: readonly ["owner", "admin", "member"];
+                readonly description: "Role for the participant in this room.";
+            };
+        };
+        readonly required: readonly ["name"];
+    };
+    readonly thenvoi_remove_participant: {
+        readonly description: "Remove a participant from the chat room by name.";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of the participant to remove.";
+            };
+        };
+        readonly required: readonly ["name"];
+    };
+    readonly thenvoi_get_participants: {
+        readonly description: "Get a list of all participants in the current chat room.";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+    readonly thenvoi_lookup_peers: {
+        readonly description: string;
+        readonly properties: {
+            readonly page: {
+                readonly type: "integer";
+                readonly description: "Page number.";
+            };
+            readonly page_size: {
+                readonly type: "integer";
+                readonly description: "Items per page (max 100).";
+                readonly maximum: 100;
+            };
+        };
+        readonly required: readonly [];
+    };
+    readonly thenvoi_create_chatroom: {
+        readonly description: "Create a new chat room for a specific task or conversation.";
+        readonly properties: {
+            readonly task_id: {
+                readonly type: "string";
+                readonly description: "Associated task ID (optional).";
+            };
+        };
+        readonly required: readonly [];
+    };
+    readonly thenvoi_list_contacts: {
+        readonly description: "List agent's contacts with pagination.";
+        readonly properties: {
+            readonly page: {
+                readonly type: "integer";
+                readonly description: "Page number.";
+                readonly minimum: 1;
+            };
+            readonly page_size: {
+                readonly type: "integer";
+                readonly description: "Items per page.";
+                readonly minimum: 1;
+                readonly maximum: 100;
+            };
+        };
+        readonly required: readonly [];
+    };
+    readonly thenvoi_add_contact: {
+        readonly description: string;
+        readonly properties: {
+            readonly handle: {
+                readonly type: "string";
+                readonly description: "Handle of user/agent to add (e.g., '@john' or '@john/agent-name').";
+            };
+            readonly message: {
+                readonly type: "string";
+                readonly description: "Optional message with the request.";
+            };
+        };
+        readonly required: readonly ["handle"];
+    };
+    readonly thenvoi_remove_contact: {
+        readonly description: "Remove an existing contact by handle or ID.";
+        readonly properties: {
+            readonly handle: {
+                readonly type: "string";
+                readonly description: "Contact's handle.";
+            };
+            readonly contact_id: {
+                readonly type: "string";
+                readonly description: "Or contact record ID (UUID).";
+            };
+        };
+        readonly required: readonly [];
+    };
+    readonly thenvoi_list_contact_requests: {
+        readonly description: string;
+        readonly properties: {
+            readonly page: {
+                readonly type: "integer";
+                readonly description: "Page number.";
+                readonly minimum: 1;
+            };
+            readonly page_size: {
+                readonly type: "integer";
+                readonly description: "Items per page per direction (max 100).";
+                readonly minimum: 1;
+                readonly maximum: 100;
+            };
+            readonly sent_status: {
+                readonly type: "string";
+                readonly enum: readonly ["pending", "approved", "rejected", "cancelled", "all"];
+                readonly description: "Filter sent requests by status.";
+            };
+        };
+        readonly required: readonly [];
+    };
+    readonly thenvoi_respond_contact_request: {
+        readonly description: string;
+        readonly properties: {
+            readonly action: {
+                readonly type: "string";
+                readonly enum: readonly ["approve", "reject", "cancel"];
+                readonly description: "Action to take.";
+            };
+            readonly handle: {
+                readonly type: "string";
+                readonly description: "Other party's handle.";
+            };
+            readonly request_id: {
+                readonly type: "string";
+                readonly description: "Or request ID (UUID).";
+            };
+        };
+        readonly required: readonly ["action"];
+    };
+    readonly thenvoi_list_memories: {
+        readonly description: string;
+        readonly properties: {
+            readonly subject_id: {
+                readonly type: "string";
+                readonly description: "Filter by subject UUID (required for subject-scoped queries).";
+            };
+            readonly scope: {
+                readonly type: "string";
+                readonly enum: readonly ["subject", "organization", "all"];
+                readonly description: "Filter by scope.";
+            };
+            readonly system: {
+                readonly type: "string";
+                readonly enum: readonly ["sensory", "working", "long_term"];
+                readonly description: "Filter by memory system.";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["iconic", "echoic", "haptic", "episodic", "semantic", "procedural"];
+                readonly description: "Filter by memory type.";
+            };
+            readonly segment: {
+                readonly type: "string";
+                readonly enum: readonly ["user", "agent", "tool", "guideline"];
+                readonly description: "Filter by segment.";
+            };
+            readonly content_query: {
+                readonly type: "string";
+                readonly description: "Full-text search query.";
+            };
+            readonly page_size: {
+                readonly type: "integer";
+                readonly description: "Number of results per page.";
+                readonly minimum: 1;
+                readonly maximum: 50;
+            };
+            readonly status: {
+                readonly type: "string";
+                readonly enum: readonly ["active", "superseded", "archived", "all"];
+                readonly description: "Filter by status.";
+            };
+        };
+        readonly required: readonly [];
+    };
+    readonly thenvoi_store_memory: {
+        readonly description: string;
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "The memory content.";
+            };
+            readonly system: {
+                readonly type: "string";
+                readonly enum: readonly ["sensory", "working", "long_term"];
+                readonly description: "Memory system tier.";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["iconic", "echoic", "haptic", "episodic", "semantic", "procedural"];
+                readonly description: "Memory type (must be valid for selected system).";
+            };
+            readonly segment: {
+                readonly type: "string";
+                readonly enum: readonly ["user", "agent", "tool", "guideline"];
+                readonly description: "Logical segment.";
+            };
+            readonly thought: {
+                readonly type: "string";
+                readonly description: "Agent's reasoning for storing this memory.";
+            };
+            readonly scope: {
+                readonly type: "string";
+                readonly enum: readonly ["subject", "organization"];
+                readonly description: "Visibility scope.";
+            };
+            readonly subject_id: {
+                readonly type: "string";
+                readonly description: "UUID of the subject this memory is about (required for subject scope).";
+            };
+            readonly metadata: {
+                readonly type: "object";
+                readonly description: "Additional metadata (tags, references).";
+            };
+        };
+        readonly required: readonly ["content", "system", "type", "segment", "thought"];
+    };
+    readonly thenvoi_get_memory: {
+        readonly description: "Retrieve a specific memory by ID.";
+        readonly properties: {
+            readonly memory_id: {
+                readonly type: "string";
+                readonly description: "Memory ID (UUID).";
+            };
+        };
+        readonly required: readonly ["memory_id"];
+    };
+    readonly thenvoi_supersede_memory: {
+        readonly description: string;
+        readonly properties: {
+            readonly memory_id: {
+                readonly type: "string";
+                readonly description: "Memory ID (UUID).";
+            };
+        };
+        readonly required: readonly ["memory_id"];
+    };
+    readonly thenvoi_archive_memory: {
+        readonly description: string;
+        readonly properties: {
+            readonly memory_id: {
+                readonly type: "string";
+                readonly description: "Memory ID (UUID).";
+            };
+        };
+        readonly required: readonly ["memory_id"];
+    };
+};
+declare const ALL_TOOL_NAMES: Set<string>;
+declare const MEMORY_TOOL_NAMES: Set<string>;
+declare const CONTACT_TOOL_NAMES: Set<string>;
+declare const BASE_TOOL_NAMES: Set<string>;
+declare const CHAT_TOOL_NAMES: Set<string>;
+declare const MCP_TOOL_PREFIX = "mcp__thenvoi__";
+declare function mcpToolNames(names: Set<string>): string[];
+declare function getToolDescription(name: string): string;
+
+export { AgentRuntime as A, BASE_TOOL_NAMES as B, CHAT_TOOL_NAMES as C, DefaultPreprocessor as D, type ExecutionContextOptions as E, MCP_TOOL_PREFIX as M, PlatformRuntime as P, TOOL_MODELS as T, type PlatformRuntimeOptions as a, ThenvoiLink as b, ExecutionContext as c, ALL_TOOL_NAMES as d, CONTACT_TOOL_NAMES as e, type ExecutionState as f, MEMORY_TOOL_NAMES as g, MessageRetryTracker as h, getToolDescription as i, mcpToolNames as m };