@canonmsg/core 0.2.2

package/dist/client.d.ts

@@ -0,0 +1,54 @@
+import { type CanonMessage, type CanonConversation, type AgentContext, type SendMessageOptions, type CreateConversationOptions, type RegistrationStatus, type SetStreamingOptions } from './types.js';
+/**
+ * Thin REST client for Canon's agent API.
+ * Uses native fetch — no runtime dependencies.
+ */
+export declare class CanonClient {
+    private baseUrl;
+    private apiKey;
+    constructor(apiKey: string, baseUrl?: string);
+    private authHeaders;
+    getAuthToken(): Promise<{
+        token: string;
+        expiresAt: string;
+        agentId: string;
+    }>;
+    getAgentMe(): Promise<AgentContext>;
+    getConversations(): Promise<CanonConversation[]>;
+    getMessages(conversationId: string, limit?: number, before?: string): Promise<CanonMessage[]>;
+    sendMessage(conversationId: string, text: string, options?: SendMessageOptions): Promise<{
+        messageId: string;
+    }>;
+    createConversation(options: CreateConversationOptions): Promise<{
+        conversationId: string;
+    }>;
+    uploadMedia(conversationId: string, data: string, mimeType: string): Promise<{
+        url: string;
+    }>;
+    updateTopic(conversationId: string, topic: string): Promise<void>;
+    deleteMessage(conversationId: string, messageId: string): Promise<void>;
+    markAsRead(conversationId: string): Promise<void>;
+    leaveConversation(conversationId: string): Promise<void>;
+    react(conversationId: string, messageId: string, emoji: string): Promise<void>;
+    updateConversationName(conversationId: string, name: string): Promise<void>;
+    addMember(conversationId: string, userId: string): Promise<void>;
+    removeMember(conversationId: string, userId: string): Promise<void>;
+    setStreaming(options: SetStreamingOptions): Promise<void>;
+    clearStreaming(conversationId: string): Promise<void>;
+    setTyping(conversationId: string, typing: boolean, status?: 'thinking' | 'typing'): Promise<void>;
+    static register(baseUrl: string | undefined, body: {
+        name: string;
+        description: string;
+        ownerPhone: string;
+        developerInfo: string;
+        avatarUrl?: string;
+        clientType?: string;
+    }): Promise<{
+        requestId: string;
+    }>;
+    static checkStatus(baseUrl: string | undefined, requestId: string): Promise<RegistrationStatus>;
+}
+export declare class CanonApiError extends Error {
+    status: number;
+    constructor(status: number, body: string);
+}

package/dist/client.js

@@ -0,0 +1,208 @@
+import { DEFAULT_BASE_URL } from './constants.js';
+/**
+ * Thin REST client for Canon's agent API.
+ * Uses native fetch — no runtime dependencies.
+ */
+export class CanonClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl || DEFAULT_BASE_URL;
+    }
+    authHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    // ── Authenticated endpoints ──────────────────────────────────────────
+    async getAuthToken() {
+        const res = await fetch(`${this.baseUrl}/agents/auth-token`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async getAgentMe() {
+        const res = await fetch(`${this.baseUrl}/agents/me`, {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async getConversations() {
+        const res = await fetch(`${this.baseUrl}/conversations`, {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        const data = await res.json();
+        return data.conversations;
+    }
+    async getMessages(conversationId, limit = 50, before) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (before)
+            params.set('before', before);
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/messages?${params}`, { headers: this.authHeaders() });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        const data = await res.json();
+        return data.messages;
+    }
+    async sendMessage(conversationId, text, options) {
+        const res = await fetch(`${this.baseUrl}/messages/send`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, text, ...(options ?? {}) }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async createConversation(options) {
+        const res = await fetch(`${this.baseUrl}/conversations/create`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify(options),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async uploadMedia(conversationId, data, mimeType) {
+        const res = await fetch(`${this.baseUrl}/media/upload`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, mimeType, data }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    async updateTopic(conversationId, topic) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/topic`, {
+            method: 'PATCH',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ topic }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async deleteMessage(conversationId, messageId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/messages/${messageId}`, {
+            method: 'DELETE',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async markAsRead(conversationId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/read`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async leaveConversation(conversationId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/leave`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async react(conversationId, messageId, emoji) {
+        const res = await fetch(`${this.baseUrl}/messages/react`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, messageId, emoji }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async updateConversationName(conversationId, name) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/name`, {
+            method: 'PATCH',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ name }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async addMember(conversationId, userId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/members`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ userId }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async removeMember(conversationId, userId) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/members/${userId}`, {
+            method: 'DELETE',
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async setStreaming(options) {
+        const res = await fetch(`${this.baseUrl}/streaming`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify(options),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async clearStreaming(conversationId) {
+        const res = await fetch(`${this.baseUrl}/streaming`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, streaming: false }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    async setTyping(conversationId, typing, status) {
+        const res = await fetch(`${this.baseUrl}/typing`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ conversationId, typing, ...(status ? { status } : {}) }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
+    // ── Static unauthenticated registration endpoints ────────────────────
+    static async register(baseUrl, body) {
+        const url = baseUrl || DEFAULT_BASE_URL;
+        const res = await fetch(`${url}/agents/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+    static async checkStatus(baseUrl, requestId) {
+        const url = baseUrl || DEFAULT_BASE_URL;
+        const res = await fetch(`${url}/agents/status/${requestId}`);
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
+}
+export class CanonApiError extends Error {
+    status;
+    constructor(status, body) {
+        super(`Canon API error ${status}: ${body}`);
+        this.name = 'CanonApiError';
+        this.status = status;
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_BASE_URL = "https://api-6m6mlelskq-uc.a.run.app";
+export declare const DEFAULT_STREAM_URL = "https://canon-agent-stream-195218560334.us-central1.run.app";
+export declare const DEFAULT_RTDB_URL = "https://project-007a8e71-ba01-49e6-8aa-default-rtdb.firebaseio.com";
+export declare const FIREBASE_WEB_API_KEY = "AIzaSyA2_NLI-WzblGsEDB2Qv8053dv7EdGE4lE";

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const DEFAULT_BASE_URL = 'https://api-6m6mlelskq-uc.a.run.app';
+export const DEFAULT_STREAM_URL = 'https://canon-agent-stream-195218560334.us-central1.run.app';
+export const DEFAULT_RTDB_URL = 'https://project-007a8e71-ba01-49e6-8aa-default-rtdb.firebaseio.com';
+export const FIREBASE_WEB_API_KEY = 'AIzaSyA2_NLI-WzblGsEDB2Qv8053dv7EdGE4lE';

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { AGENT_CAPABILITIES, } from './types.js';
+export type { AgentCapabilities, AgentClientType, CanonMessage, CanonConversation, AgentContext, MessageCreatedPayload, TypingPayload, PresencePayload, SendMessageOptions, CreateConversationOptions, RegistrationInput, RegistrationResult, RegistrationStatus, StreamingStatus, SetStreamingOptions, SessionControl, SessionState, SessionConfig, AgentRuntime, ModelOption, WorkspaceOption, } from './types.js';
+export { CanonClient, CanonApiError } from './client.js';
+export { CanonStream } from './stream.js';
+export type { StreamHandler } from './stream.js';
+export { registerAndWaitForApproval } from './registration.js';
+export { ApprovalManager } from './approval-manager.js';
+export { generateApprovalId, buildApprovalRequest, buildApprovalReply, buildApprovalOutcome, parseTextApprovalReply, redactSecrets, } from './approval-format.js';
+export { DEFAULT_APPROVAL_CONFIG, } from './approval-types.js';
+export type { ApprovalRequestMetadata, ApprovalReplyMetadata, SessionRule, ApprovalResult, ApprovalConfig, } from './approval-types.js';
+export { createStreamingHelper } from './streaming.js';
+export type { RTDBHandle, RTDBRef, ServerTimestamp, StreamingHelperOptions, StreamingNode } from './streaming.js';
+export { loadProfiles, isProfileLocked, acquireLock, releaseLock, isProcessAlive, CANON_DIR, AGENTS_PATH, LOCKS_DIR, } from './agent-profiles.js';
+export type { AgentProfile } from './agent-profiles.js';
+export { resolveCanonAgent, getActiveProfile } from './agent-resolver.js';
+export type { ResolvedAgent } from './agent-resolver.js';
+export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState } from './rtdb-rest.js';
+export type { SessionStatePayload } from './rtdb-rest.js';
+export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL, DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';

package/dist/index.js

@@ -0,0 +1,22 @@
+// Types
+export { AGENT_CAPABILITIES, } from './types.js';
+// Client
+export { CanonClient, CanonApiError } from './client.js';
+// Stream
+export { CanonStream } from './stream.js';
+// Registration
+export { registerAndWaitForApproval } from './registration.js';
+// Approval
+export { ApprovalManager } from './approval-manager.js';
+export { generateApprovalId, buildApprovalRequest, buildApprovalReply, buildApprovalOutcome, parseTextApprovalReply, redactSecrets, } from './approval-format.js';
+export { DEFAULT_APPROVAL_CONFIG, } from './approval-types.js';
+// Streaming (RTDB helpers)
+export { createStreamingHelper } from './streaming.js';
+// Agent profiles (loading, locking, resolution)
+export { loadProfiles, isProfileLocked, acquireLock, releaseLock, isProcessAlive, CANON_DIR, AGENTS_PATH, LOCKS_DIR, } from './agent-profiles.js';
+// Agent resolver
+export { resolveCanonAgent, getActiveProfile } from './agent-resolver.js';
+// RTDB REST helpers (token exchange, session state, generic read/write)
+export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState } from './rtdb-rest.js';
+// Constants
+export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL, DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';

package/dist/registration.d.ts

@@ -0,0 +1,13 @@
+import type { RegistrationInput, RegistrationResult, RegistrationStatus } from './types.js';
+/**
+ * Registers a new Canon agent and polls for owner approval.
+ *
+ * Flow:
+ * 1. POST /agents/register -> returns requestId
+ * 2. Poll GET /agents/status/:requestId until approved/rejected/timeout
+ * 3. On approval, returns the API key
+ */
+export declare function registerAndWaitForApproval(input: RegistrationInput, callbacks?: {
+    onSubmitted?: (requestId: string) => void;
+    onPollUpdate?: (status: RegistrationStatus) => void;
+}): Promise<RegistrationResult>;

package/dist/registration.js

@@ -0,0 +1,46 @@
+import { CanonClient } from './client.js';
+const POLL_INTERVAL_MS = 3_000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Registers a new Canon agent and polls for owner approval.
+ *
+ * Flow:
+ * 1. POST /agents/register -> returns requestId
+ * 2. Poll GET /agents/status/:requestId until approved/rejected/timeout
+ * 3. On approval, returns the API key
+ */
+export async function registerAndWaitForApproval(input, callbacks) {
+    const { requestId } = await CanonClient.register(input.baseUrl, {
+        name: input.name,
+        description: input.description,
+        ownerPhone: input.ownerPhone,
+        developerInfo: input.developerInfo || 'Canon agent',
+        avatarUrl: input.avatarUrl,
+        clientType: input.clientType,
+    });
+    callbacks?.onSubmitted?.(requestId);
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await sleep(POLL_INTERVAL_MS);
+        const result = await CanonClient.checkStatus(input.baseUrl, requestId);
+        callbacks?.onPollUpdate?.(result);
+        if (result.status === 'approved') {
+            return {
+                status: 'approved',
+                apiKey: result.apiKey,
+                agentId: result.agentId,
+                agentName: result.agentName,
+            };
+        }
+        if (result.status === 'rejected') {
+            return {
+                status: 'rejected',
+                agentName: result.agentName,
+            };
+        }
+    }
+    return { status: 'timeout' };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/rtdb-rest.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Lightweight RTDB REST helper for session state.
+ *
+ * Uses Firebase Realtime Database REST API to avoid adding firebase-admin
+ * as a dependency to the MCP plugin. The custom token from /agents/auth-token
+ * is exchanged for a Firebase ID token before use with RTDB REST.
+ */
+import type { CanonClient } from './client.js';
+export interface SessionStatePayload {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    cwd?: string;
+    hostMode?: boolean;
+    clientType?: string;
+    isActive: boolean;
+    state?: 'idle' | 'running' | 'requires_action';
+    contextUsage?: {
+        percentage: number;
+        totalTokens: number;
+        maxTokens: number;
+    };
+    availableModels?: Array<{
+        value: string;
+        label: string;
+    }>;
+    updatedAt: {
+        '.sv': 'timestamp';
+    };
+}
+/** Must be called once before any RTDB operations. */
+export declare function initRTDBAuth(client: CanonClient): void;
+/** Generic RTDB REST write (PUT). */
+export declare function rtdbWrite(path: string, data: unknown): Promise<void>;
+/** Generic RTDB REST read (GET). */
+export declare function rtdbRead(path: string): Promise<unknown>;
+/**
+ * Write session state to RTDB via REST API.
+ * Path: /session-state/{conversationId}/{agentId}
+ */
+export declare function writeSessionState(conversationId: string, agentId: string, state: Omit<SessionStatePayload, 'updatedAt'>): Promise<void>;
+/**
+ * Clear session state from RTDB (full overwrite with isActive: false).
+ */
+export declare function clearSessionState(conversationId: string, agentId: string): Promise<void>;

package/dist/rtdb-rest.js

@@ -0,0 +1,128 @@
+/**
+ * Lightweight RTDB REST helper for session state.
+ *
+ * Uses Firebase Realtime Database REST API to avoid adding firebase-admin
+ * as a dependency to the MCP plugin. The custom token from /agents/auth-token
+ * is exchanged for a Firebase ID token before use with RTDB REST.
+ */
+import { DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';
+const RTDB_BASE = process.env.CANON_RTDB_URL || DEFAULT_RTDB_URL;
+const FIREBASE_API_KEY = process.env.CANON_FIREBASE_API_KEY || FIREBASE_WEB_API_KEY;
+// ── Token management ──────────────────────────────────────────────────
+let cachedIdToken = null;
+let idTokenExpiresAt = 0;
+let tokenClient = null;
+/** Must be called once before any RTDB operations. */
+export function initRTDBAuth(client) {
+    tokenClient = client;
+}
+/**
+ * Exchange a Firebase custom token for an ID token via the Identity Toolkit API.
+ */
+async function exchangeCustomTokenForIdToken(customToken) {
+    const url = `https://identitytoolkit.googleapis.com/v1/accounts:signInWithCustomToken?key=${FIREBASE_API_KEY}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token: customToken, returnSecureToken: true }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Token exchange failed (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    return { idToken: data.idToken, expiresIn: parseInt(data.expiresIn, 10) };
+}
+/** Get a valid ID token for RTDB REST, refreshing if expired or expiring soon. */
+async function getToken() {
+    // Refresh if missing, expired, or expiring within 5 minutes
+    if (!cachedIdToken || Date.now() > idTokenExpiresAt - 5 * 60 * 1000) {
+        if (!tokenClient)
+            return null;
+        try {
+            const auth = await tokenClient.getAuthToken();
+            const { idToken, expiresIn } = await exchangeCustomTokenForIdToken(auth.token);
+            cachedIdToken = idToken;
+            idTokenExpiresAt = Date.now() + expiresIn * 1000;
+        }
+        catch (err) {
+            console.error('[canon] RTDB token refresh failed:', err);
+            return cachedIdToken; // Return stale token as fallback
+        }
+    }
+    return cachedIdToken;
+}
+// ── RTDB operations ───────────────────────────────────────────────────
+/** Generic RTDB REST write (PUT). */
+export async function rtdbWrite(path, data) {
+    const token = await getToken();
+    if (!token)
+        return;
+    const url = `${RTDB_BASE}${path}.json?auth=${token}`;
+    const res = await fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`RTDB write failed (${res.status}): ${text}`);
+    }
+}
+/** Generic RTDB REST read (GET). */
+export async function rtdbRead(path) {
+    const token = await getToken();
+    if (!token)
+        return null;
+    const url = `${RTDB_BASE}${path}.json?auth=${token}`;
+    const res = await fetch(url);
+    if (!res.ok)
+        return null;
+    return res.json();
+}
+/**
+ * Write session state to RTDB via REST API.
+ * Path: /session-state/{conversationId}/{agentId}
+ */
+export async function writeSessionState(conversationId, agentId, state) {
+    const token = await getToken();
+    if (!token)
+        return;
+    const url = `${RTDB_BASE}/session-state/${conversationId}/${agentId}.json?auth=${token}`;
+    const body = {
+        ...state,
+        updatedAt: { '.sv': 'timestamp' },
+    };
+    const res = await fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`RTDB write failed (${res.status}): ${text}`);
+    }
+}
+/**
+ * Clear session state from RTDB (full overwrite with isActive: false).
+ */
+export async function clearSessionState(conversationId, agentId) {
+    const token = await getToken();
+    if (!token)
+        return;
+    const url = `${RTDB_BASE}/session-state/${conversationId}/${agentId}.json?auth=${token}`;
+    const body = {
+        isActive: false,
+        updatedAt: { '.sv': 'timestamp' },
+    };
+    // Use PUT (not PATCH) to clear stale fields like model/cwd
+    const res = await fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        console.error(`[canon] RTDB clear failed (${res.status}): ${text}`);
+    }
+}

package/dist/stream.d.ts

@@ -0,0 +1,54 @@
+import type { AgentContext, MessageCreatedPayload, TypingPayload, PresencePayload } from './types.js';
+export type StreamHandler = {
+    onMessage: (payload: MessageCreatedPayload) => void;
+    onAgentContext?: (ctx: AgentContext) => void;
+    onTyping?: (data: TypingPayload) => void;
+    onPresence?: (data: PresencePayload) => void;
+    onMessageDeleted?: (payload: {
+        conversationId: string;
+        messageId: string;
+    }) => void;
+    onConversationUpdated?: (payload: {
+        conversationId: string;
+        changes: Record<string, unknown>;
+    }) => void;
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+    onError?: (error: Error) => void;
+};
+/**
+ * Manages a persistent SSE connection to Canon's stream service.
+ *
+ * Uses native fetch + ReadableStream (Node 18+) — no EventSource polyfill.
+ * Supports Last-Event-ID for gapless replay on reconnect.
+ */
+export declare class CanonStream {
+    private apiKey;
+    private agentId;
+    private streamUrl;
+    private handler;
+    private running;
+    private abortController;
+    private lastEventId;
+    private reconnectAttempt;
+    private reconnectTimer;
+    constructor(opts: {
+        apiKey: string;
+        agentId: string;
+        streamUrl?: string;
+        handler: StreamHandler;
+    });
+    start(): Promise<void>;
+    stop(): void;
+    isRunning(): boolean;
+    private connect;
+    private readStream;
+    private processFrame;
+    private handleAgentContext;
+    private handleMessageCreated;
+    private handleTyping;
+    private handlePresence;
+    private handleMessageDeleted;
+    private handleConversationUpdated;
+    private scheduleReconnect;
+}