@canonmsg/agent-sdk 10.2.1 → 10.3.0

package/dist/attached-session.js

@@ -0,0 +1,555 @@
+import { createHash } from 'node:crypto';
+import { buildChunkedMessagePartMetadata, CanonClient, CanonStream, createAttachedNativeSession, createRuntimeHeartbeat, createRuntimeStatePublisher, initRTDBAuth, resolveCanonRuntimeConnection, splitTextByUtf8Bytes, verifyCanonRuntimeConnection, } from '@canonmsg/core';
+/**
+ * Connect one existing native session to one existing Canon conversation.
+ * This is account-level participation, not a second group member. The caller
+ * must hold exclusive account and native-session ownership so no competing
+ * runtime writes this account's live state or republishes the native thread.
+ */
+export function createCanonAttachedSession(options) {
+    const binding = structuredClone(options.binding);
+    const connection = { ...options.connection };
+    if (binding.agentId !== connection.agentId || binding.environmentId !== connection.environmentId) {
+        throw new Error('Attached session account/environment does not match its Canon connection');
+    }
+    if (options.transport && (options.transport.agentId !== binding.agentId
+        || options.transport.environmentId !== binding.environmentId)) {
+        throw new Error('Shared attachment transport belongs to a different account or environment');
+    }
+    const intervalMs = options.reconcileIntervalMs ?? 10_000;
+    if (!Number.isFinite(intervalMs) || intervalMs < 1)
+        throw new Error('Invalid attachment reconciliation interval');
+    const runtimeConnection = resolveCanonRuntimeConnection({
+        environmentId: connection.environmentId,
+        apiBaseUrl: connection.baseUrl,
+        streamUrl: connection.streamUrl,
+        rtdbUrl: connection.rtdbUrl,
+        firebaseWebApiKey: connection.firebaseApiKey,
+    });
+    const client = options.transport?.client ?? new CanonClient(connection.apiKey, runtimeConnection.apiBaseUrl);
+    let stopped = false;
+    let running = false;
+    let connected = false;
+    let startPromise;
+    let stopPromise;
+    let cleanupPromise;
+    let coreStopPromise;
+    let timer;
+    let stream;
+    let unsubscribeStream;
+    let publisher;
+    let heartbeat;
+    let stateWrites = Promise.resolve();
+    let recoveryPromise;
+    let nativeReconcilePromise;
+    const tasks = new Set();
+    const receiving = new Set();
+    const reportedHistory = new Set();
+    let publicationFailed = false;
+    let historyIncomplete = false;
+    let inputError = null;
+    let observedTurnId;
+    let turnUpdatedAt = null;
+    const observedTurnItems = new Set();
+    const report = (error, operation) => {
+        if (operation === 'publish') {
+            publicationFailed = true;
+            publishState(core.getState());
+        }
+        else if (operation === 'history-recovery') {
+            historyIncomplete = true;
+            publishState(core.getState());
+        }
+        try {
+            options.onError?.(error, operation);
+        }
+        catch { /* Callbacks do not own the lifecycle. */ }
+    };
+    const emit = (status) => {
+        try {
+            options.onStatus?.(status);
+        }
+        catch (error) {
+            report(error, 'status');
+        }
+    };
+    const track = (task, operation) => {
+        tasks.add(task);
+        void task.catch((error) => report(error, operation)).finally(() => tasks.delete(task));
+    };
+    const transcriptPublisher = createCanonAttachedSessionPublisher(client, binding);
+    const core = createAttachedNativeSession({
+        binding, store: options.store, adapter: options.native,
+        isPublicationReady: () => options.transport?.isRouteActive?.(binding.conversationId) !== false,
+        publisher: {
+            prepare(input) {
+                const parts = transcriptPublisher.prepare(input);
+                if (parts.length && input.item.turnId === observedTurnId) {
+                    const key = JSON.stringify([input.item.itemId, input.item.role]);
+                    if (!observedTurnItems.has(key)) {
+                        observedTurnItems.add(key);
+                        turnUpdatedAt = Date.now();
+                    }
+                }
+                return parts;
+            },
+            send: (part) => transcriptPublisher.send(part),
+        },
+        onError: report,
+        onState: (nativeState) => {
+            emit({ status: 'native', nativeState });
+            publishState(nativeState);
+        },
+    });
+    function publishState(state) {
+        if (!publisher || !running || stopped)
+            return;
+        if (state.activeTurnId !== observedTurnId) {
+            observedTurnId = state.activeTurnId;
+            observedTurnItems.clear();
+            turnUpdatedAt = state.activeTurnId ? Date.now() : null;
+        }
+        // Core also notifies on unchanged inspection and outbox writes. Preserve
+        // turn freshness across those liveness updates. This adapter observes
+        // completed text and accepted input, not every native tool/generation event.
+        const observedProgressAt = turnUpdatedAt;
+        // Clear only on a current notification; an older queued RTDB write must
+        // not erase a publication failure observed while it awaited the network.
+        if (state.pendingPublicationCount === 0)
+            publicationFailed = false;
+        const canReceive = state.status === 'ready' && options.transport?.isRouteActive?.(binding.conversationId) !== false;
+        if (connected && (canReceive || state.status === 'uncertain'))
+            heartbeat?.connect();
+        else
+            track(heartbeat?.disconnect() ?? Promise.resolve(), 'heartbeat-disconnect');
+        stateWrites = stateWrites.then(async () => {
+            if (!publisher || !running || stopped)
+                return;
+            const errors = [
+                state.status === 'uncertain' ? 'Native input acceptance is uncertain; new inputs are blocked and will not be queued.' : null,
+                publicationFailed && state.pendingPublicationCount > 0
+                    ? `${state.pendingPublicationCount} native transcript part(s) await publication. Canon has not accepted this output; delivery will retry.` : null,
+                reportedHistory.size > 0
+                    ? `${reportedHistory.size} Canon message(s) were observed in history without live dispatch permission and were not submitted. Send a new message to request work.` : null,
+                historyIncomplete ? 'Canon history recovery could not establish the full gap. Historical inputs are not automatically submitted.' : null,
+                inputError,
+            ].filter(Boolean).join(' ');
+            await publisher.writeSessionState(binding.conversationId, { isActive: connected && canReceive, lastError: errors });
+            await publisher.writeTurnState(binding.conversationId, {
+                state: state.activeTurnId
+                    ? options.transport?.hasPendingInteraction?.(binding.conversationId) ? 'waiting_input' : 'thinking'
+                    : 'idle',
+                turnId: state.activeTurnId,
+                turnUpdatedAt: observedProgressAt,
+                queueDepth: 0,
+                capabilities: {
+                    supportsQueue: false, supportsInputInterrupt: false, supportsInterrupt: false,
+                    supportsInterleave: false, supportsRequiresAction: Boolean(options.transport?.hasPendingInteraction), supportsNonFinalPermanentMessages: false,
+                },
+            });
+            await publisher.patchAgentSessionSnapshot(binding.conversationId, {
+                supportsQueue: false,
+                supportsInputInterrupt: false,
+                lastError: errors || null,
+            });
+        }).catch((error) => report(error, 'runtime-state'));
+    }
+    async function notice(payload, text) {
+        if (stopped)
+            return;
+        const authority = payload.replyAuthority;
+        const id = `attached_notice_${createHash('sha256').update(JSON.stringify([
+            binding, payload.message.id,
+        ])).digest('hex').slice(0, 40)}`;
+        // A refusal notice responds only to this Canon input. Shared native
+        // output never receives this capability.
+        if (authority && authority.sourceMessageId === payload.message.id
+            && Date.parse(authority.expiresAt) > Date.now()) {
+            await client.sendMessage(binding.conversationId, text, {
+                messageId: id, replyTo: payload.message.id, replyAuthority: authority,
+                metadata: { type: 'attached_input_notice', turnId: id, replyBehavior: 'suppress_auto_reply' },
+            });
+        }
+        else {
+            report(new Error(text), 'input-unavailable');
+        }
+    }
+    function detach(reason) {
+        emit({ status: 'blocked', reason });
+        void stop().catch((error) => report(error, 'detach'));
+    }
+    async function verifyMembership() {
+        const conversations = await client.getConversations();
+        if (stopped)
+            return false;
+        const conversation = conversations.find((entry) => entry.id === binding.conversationId);
+        if (!conversation?.memberIds.includes(binding.agentId)) {
+            detach('conversation-membership-lost');
+            return false;
+        }
+        return true;
+    }
+    async function receive(payload) {
+        if (!running || stopped || payload.conversationId !== binding.conversationId)
+            return;
+        if (options.transport?.isRouteActive?.(binding.conversationId) === false)
+            return;
+        const message = payload.message;
+        if (message.senderId === binding.agentId || core.hasCanonMessage(message.id)
+            || core.isBeforeCanonBaseline(message.id, message.createdAt ?? '') || receiving.has(message.id))
+            return;
+        if (payload.provenance && (payload.provenance.conversation.id !== binding.conversationId
+            || payload.provenance.sender.id !== message.senderId)) {
+            emit({ status: 'blocked', reason: 'invalid-provenance', messageId: message.id });
+            return;
+        }
+        receiving.add(message.id);
+        try {
+            if (payload.turnDispatch?.kind !== 'run_turn') {
+                await core.recordSkippedCanonMessage(message.id, 'not-dispatched');
+                emit({ status: 'blocked', reason: 'not-dispatched', messageId: message.id });
+                return;
+            }
+            if (!message.createdAt || !Number.isFinite(Date.parse(message.createdAt))) {
+                await core.recordSkippedCanonMessage(message.id, 'missing-timestamp');
+                emit({ status: 'blocked', reason: 'missing-timestamp', messageId: message.id });
+                inputError = 'This message has no valid Canon timestamp, so it could not safely be distinguished from attachment history and was not submitted.';
+                publishState(core.getState());
+                await notice(payload, inputError);
+                return;
+            }
+            if (message.contentType !== 'text' || !message.text?.trim() || message.attachments?.length) {
+                await core.recordSkippedCanonMessage(message.id, 'unsupported-content');
+                emit({ status: 'blocked', reason: 'unsupported-content', messageId: message.id });
+                inputError = 'This attached session accepts text messages. This message was not submitted to the native session.';
+                publishState(core.getState());
+                await notice(payload, inputError);
+                return;
+            }
+            const result = await core.submit({
+                messageId: message.id,
+                text: `Canon message from ${message.senderName ?? message.senderId} (${message.senderType}):\n\n${message.text}`,
+                ...(payload.replyAuthority ? { replyAuthority: payload.replyAuthority } : {}),
+            });
+            if (stopped)
+                return;
+            reportedHistory.delete(message.id);
+            if (result.status === 'accepted') {
+                if (result.turnId === observedTurnId && !result.replayed)
+                    turnUpdatedAt = Date.now();
+                // Acceptance is not completion. The current read API advances the
+                // account's conversation read state, not an independent session cursor.
+                await client.markAsRead(binding.conversationId).catch((error) => report(error, 'mark-read'));
+                inputError = null;
+                emit({ status: 'accepted', messageId: message.id, reason: result.mode });
+            }
+            else {
+                // A refusal caused by another uncertain input, or a disconnected
+                // adapter, is not journaled by Core. Retain this rejected ID so replay
+                // cannot turn a "not submitted" notice into later automatic work.
+                if (!core.hasCanonMessage(message.id))
+                    await core.recordSkippedCanonMessage(message.id, result.status);
+                emit({ status: 'blocked', messageId: message.id, reason: result.status });
+                const text = result.status === 'uncertain'
+                    ? result.messageId === message.id
+                        ? 'The native session may have accepted this input, but its acknowledgement is uncertain. It will not be submitted again automatically.'
+                        : 'An earlier native input has an uncertain acknowledgement. This message was not submitted or queued; send it again after the attachment recovers.'
+                    : result.status === 'busy'
+                        ? 'The attachment is handling another input submission. This message was not queued or submitted; send it again when the attachment is ready.'
+                        : 'This message was not submitted because the native session is unavailable. Send it again when the attachment is ready.';
+                inputError = text;
+                publishState(core.getState());
+                await notice(payload, text);
+            }
+            publishState(core.getState());
+        }
+        finally {
+            receiving.delete(message.id);
+        }
+    }
+    function recoverHistory() {
+        if (recoveryPromise)
+            return recoveryPromise;
+        recoveryPromise = (async () => {
+            let before;
+            const cursors = new Set();
+            const missing = [];
+            let establishedBoundary = false;
+            // REST cannot mint the run_turn dispatch and reply capability supplied
+            // by SSE. Inspect gaps for visibility; never execute these observations.
+            for (let pageNumber = 0; pageNumber < 20 && !stopped; pageNumber += 1) {
+                const page = await client.getMessagesPage(binding.conversationId, 100, before);
+                if (!page.messages.length)
+                    break;
+                let reachedKnown = false;
+                for (const message of page.messages) {
+                    if (core.hasCanonMessage(message.id) || core.isBeforeCanonBaseline(message.id, message.createdAt)) {
+                        reachedKnown = true;
+                    }
+                    else if (message.senderId !== binding.agentId && !receiving.has(message.id)
+                        && !reportedHistory.has(message.id)) {
+                        missing.push(message.id);
+                        reportedHistory.add(message.id);
+                    }
+                }
+                if (reachedKnown) {
+                    establishedBoundary = true;
+                    break;
+                }
+                const cursor = page.messages[page.messages.length - 1].id;
+                if (cursors.has(cursor))
+                    throw new Error('Canon history cursor did not advance');
+                cursors.add(cursor);
+                before = cursor;
+            }
+            if (!stopped && missing.length)
+                emit({
+                    status: 'blocked', reason: 'history-without-live-dispatch', pendingMessageIds: missing,
+                });
+            // The current endpoint applies its limit before filtering hidden rows
+            // and has no continuation token. An empty page cannot prove exhaustion.
+            if (missing.length && !establishedBoundary)
+                historyIncomplete = true;
+            publishState(core.getState());
+        })().finally(() => { recoveryPromise = undefined; });
+        return recoveryPromise;
+    }
+    async function cleanup() {
+        cleanupPromise ??= (async () => {
+            running = false;
+            connected = false;
+            if (timer)
+                clearInterval(timer);
+            stream?.stop();
+            unsubscribeStream?.();
+            try {
+                await stopCore();
+            }
+            finally {
+                await Promise.allSettled([...tasks, stateWrites, nativeReconcilePromise, recoveryPromise].filter(Boolean));
+                try {
+                    await heartbeat?.dispose();
+                }
+                finally {
+                    if (publisher) {
+                        const results = await Promise.allSettled([
+                            publisher.clearTurnState(binding.conversationId),
+                            publisher.clearSessionState(binding.conversationId),
+                        ]);
+                        for (const result of results)
+                            if (result.status === 'rejected')
+                                report(result.reason, 'clear-runtime');
+                    }
+                }
+            }
+        })();
+        return cleanupPromise;
+    }
+    function stopCore() {
+        coreStopPromise ??= core.stop();
+        // Shutdown can begin before startup unwinds. Attach a handler immediately;
+        // cleanup still awaits and reports the original failure.
+        void coreStopPromise.catch(() => { });
+        return coreStopPromise;
+    }
+    function start() {
+        if (stopped)
+            return Promise.reject(new Error('Attachment has stopped; create a new attachment to restart'));
+        if (startPromise)
+            return startPromise;
+        startPromise = (async () => {
+            emit({ status: 'connecting' });
+            if (!options.transport)
+                await verifyCanonRuntimeConnection(runtimeConnection);
+            if (stopped)
+                return;
+            if (!options.transport) {
+                const auth = await client.getAuthToken();
+                if (auth.agentId !== binding.agentId)
+                    throw new Error('Canon credential belongs to a different agent');
+            }
+            if (stopped)
+                return;
+            const conversations = await client.getConversations();
+            const conversation = conversations.find((entry) => entry.id === binding.conversationId);
+            if (!conversation || !conversation.memberIds.includes(binding.agentId)) {
+                throw new Error('The agent is not a member of the specified Canon conversation');
+            }
+            const initial = await client.getMessagesPage(binding.conversationId, 100);
+            if (stopped)
+                return;
+            const latest = initial.messages.reduce((value, message) => {
+                if (!Number.isFinite(Date.parse(message.createdAt)))
+                    throw new Error('Invalid Canon message timestamp');
+                return !value || Date.parse(message.createdAt) > Date.parse(value) ? message.createdAt : value;
+            }, null);
+            // Include the entire newest millisecond in the baseline. Otherwise a
+            // historical tie outside this filtered REST page could become new work
+            // when SSE backfills it. A new message stamped in that same millisecond
+            // is conservatively baseline history too; IDs alone cannot resolve it.
+            const cutoff = latest ? new Date(Date.parse(latest) + 1).toISOString() : null;
+            await core.start();
+            if (stopped)
+                return;
+            await core.initializeCanonBaseline(initial.messages.map((message) => message.id), cutoff);
+            if (stopped)
+                return;
+            if (options.transport)
+                publisher = options.transport.publisher;
+            else {
+                const rtdb = initRTDBAuth(client, {
+                    rtdbUrl: runtimeConnection.rtdbUrl, firebaseApiKey: runtimeConnection.firebaseWebApiKey,
+                });
+                publisher = createRuntimeStatePublisher({ agentId: binding.agentId, clientType: connection.clientType ?? 'generic', hostMode: false, rtdb });
+                heartbeat = createRuntimeHeartbeat({
+                    publisher,
+                    getRuntime: () => ({ runtimeDescriptor: {
+                            coreControls: [], runtimeControls: [], commands: [],
+                            supportsInterrupt: false, supportsInputInterrupt: false, streamingTextMode: 'snapshot',
+                        } }),
+                    onError: report,
+                });
+            }
+            running = true;
+            const handler = {
+                onMessage: (payload) => track(receive(payload), 'receive'),
+                onAgentContext: (context) => {
+                    if (context.agentId !== binding.agentId) {
+                        report(new Error('Canon stream context belongs to a different agent'), 'stream-identity');
+                        detach('stream-identity-mismatch');
+                    }
+                },
+                onConversationUpdated: (payload) => {
+                    if (stopped || payload.conversationId !== binding.conversationId)
+                        return;
+                    const members = payload.changes.memberIds;
+                    if ((Array.isArray(members) && !members.includes(binding.agentId))
+                        || payload.membershipChange?.removedMemberIds.includes(binding.agentId)
+                        || payload.changes.deleted === true)
+                        detach('conversation-membership-lost');
+                },
+                onParticipationSuppressed: (payload) => {
+                    if (stopped || payload.conversationId !== binding.conversationId)
+                        return;
+                    emit({ status: 'blocked', reason: payload.reasonCode, messageId: payload.messageId });
+                },
+                onConnected: () => {
+                    if (stopped || !running)
+                        return;
+                    connected = true;
+                    emit({ status: 'connected' });
+                    publishState(core.getState());
+                    track(verifyMembership().then((member) => member ? recoverHistory() : undefined), 'history-recovery');
+                },
+                onDisconnected: () => {
+                    connected = false;
+                    if (!stopped)
+                        emit({ status: 'disconnected' });
+                    publishState(core.getState());
+                    track(heartbeat?.disconnect() ?? Promise.resolve(), 'heartbeat-disconnect');
+                },
+                onReplayExpired: () => track(recoverHistory(), 'history-recovery'),
+                onError: (error) => report(error, 'stream'),
+            };
+            if (options.transport)
+                unsubscribeStream = options.transport.subscribe(handler);
+            else
+                stream = new CanonStream({
+                    apiKey: connection.apiKey, agentId: binding.agentId, streamUrl: runtimeConnection.streamUrl, handler,
+                });
+            publishState(core.getState());
+            // CanonStream.start runs for the lifetime of a fetch stream. Do not
+            // make CLI startup wait until the connection closes.
+            if (stream)
+                void stream.start().catch((error) => report(error, 'stream-start'));
+            timer = setInterval(() => {
+                if (stopped || nativeReconcilePromise)
+                    return;
+                nativeReconcilePromise = verifyMembership().then((member) => member ? core.reconcile() : undefined)
+                    .finally(() => { nativeReconcilePromise = undefined; });
+                track(nativeReconcilePromise, 'native-reconcile');
+            }, intervalMs);
+            timer.unref?.();
+        })().catch(async (error) => {
+            stopped = true;
+            await cleanup().catch((cleanupError) => report(cleanupError, 'cleanup'));
+            throw error;
+        });
+        return startPromise;
+    }
+    function stop() {
+        if (stopPromise)
+            return stopPromise;
+        stopped = true;
+        running = false;
+        if (timer)
+            clearInterval(timer);
+        stream?.stop();
+        unsubscribeStream?.();
+        stopCore();
+        stopPromise = (async () => {
+            await startPromise?.catch(() => { });
+            await cleanup();
+            emit({ status: 'stopped' });
+        })();
+        return stopPromise;
+    }
+    function refreshRuntimeState() {
+        publishState(core.getState());
+        if (running && !stopped && options.transport?.isRouteActive?.(binding.conversationId) !== false) {
+            track(core.flush(), 'publish');
+        }
+    }
+    return { start, stop, getState: core.getState, refreshRuntimeState };
+}
+/**
+ * Observed native turns may combine local and Canon input. They are proactive
+ * agent transcript publications, never replies authorized by a particular
+ * Canon input. Core persists these immutable parts before calling send.
+ */
+export function createCanonAttachedSessionPublisher(client, binding) {
+    return {
+        prepare({ item, origin }) {
+            const text = item.role === 'user'
+                ? `Local user (reported by the agent):\n\n${item.text}`
+                : item.text;
+            if (!text.trim())
+                return [];
+            const groupId = `attached_${createHash('sha256').update(JSON.stringify([
+                binding.environmentId, binding.agentId, binding.conversationId,
+                binding.provider, binding.nativeSessionId, item.turnId, item.itemId, item.role,
+            ])).digest('hex').slice(0, 40)}`;
+            const chunks = splitTextByUtf8Bytes(text, 3_800);
+            const metadata = {
+                type: 'attached_native_message',
+                replyBehavior: 'suppress_auto_reply',
+                observedRole: item.role,
+                native: {
+                    runtime: binding.provider,
+                    threadId: binding.nativeSessionId,
+                    turnId: item.turnId,
+                    itemId: item.itemId,
+                },
+                ...(origin.kind === 'shared' ? { sourceMessageIds: [...origin.sourceMessageIds] } : {}),
+            };
+            if (Buffer.byteLength(JSON.stringify(metadata), 'utf8') > 3_500) {
+                throw new Error('Native transcript correlation exceeds Canon message metadata limits');
+            }
+            return chunks.map((chunk, index) => ({
+                messageId: `${groupId}_${index + 1}`,
+                text: chunk,
+                options: {
+                    metadata: buildChunkedMessagePartMetadata({
+                        groupId, metadata, index: index + 1, count: chunks.length,
+                    }),
+                },
+            }));
+        },
+        async send(part) {
+            await client.sendProactiveMessage(binding.conversationId, part.text, {
+                metadata: part.options.metadata,
+                messageId: part.messageId,
+            });
+        },
+    };
+}

package/dist/index.d.ts

@@ -11,3 +11,11 @@ export type { SessionConfig, Session } from './session-manager.js';
 export type { CanonAgentTurnVerbosityOption } from './turn-verbosity-option.js';
 export type { AgentContext, CanonGroupContext, CanonKnownRecentParticipant, CanonMembershipChange, CanonMessage, CanonConversation, CommunicateInput, CommunicateResult, DirectConversationSelection, CanonConversationsPage, CanonConversationsPageOptions, CanonReplyContext, CanonSelfContext, CanonTurnContextV2, CanonRuntimeDescriptor, MessageUpdatedPayload, SendMessageOptions, CreateGroupOptions, CreateGroupResult, TurnVerbosity, TurnVerbosityConfig, } from '@canonmsg/core';
 export type { CanonAgentConnectionOptions, CanonAgentOptions, ContactAddedHandler, ContactRemovedHandler, FinalMessageResult, MessageHandler, MessageHandlerContext, MessageUpdatedHandler, ParticipationSuppressedHandler, ProgressMessageOptions, ProgressMessageResult, RuntimeApprovalRequest, RuntimeInputRequest, RuntimeInputResult, RuntimePlanReviewRequest, RuntimePlanReviewResult, RuntimeControlSurface, RuntimePrimitiveContext, RuntimePrimitiveHandler, RuntimePrimitiveHandlers, SessionInfo, SessionOptions, DeliveryMode, } from './types.js';
+export { createCanonAttachedSession, createCanonAttachedSessionPublisher } from './attached-session.js';
+export { createCanonWorkSessionHost } from './work-session-host.js';
+export type { CanonWorkSessionHost, CanonWorkSessionHostOptions } from './work-session-host.js';
+export { createFileWorkSessionHostStore } from './work-session-state.js';
+export type { WorkSessionHostStore, WorkSessionHostJournal } from './work-session-state.js';
+export { createFileAttachedSessionStore } from '@canonmsg/core';
+export type { CanonAttachedSession, CanonAttachedSessionConnection, CanonAttachedSessionOptions, CanonAttachedSessionStatus, } from './attached-session.js';
+export type { AttachedNativeSessionAdapter, AttachedSessionBinding, AttachedSessionJournal, AttachedSessionState, AttachedSessionStore, NativeSessionEvent, NativeSessionItem, NativeSessionSnapshot, NativeSubmissionResult, } from '@canonmsg/core';

package/dist/index.js

@@ -3,3 +3,7 @@ export { clearPendingRegistration, ensureAgentProfile, resumeRegistration } from
 export { ApprovalManager, buildApprovalOutcome, buildApprovalReply, buildApprovalRequest, CanonApiError, DEFAULT_APPROVAL_CONFIG, generateApprovalId, HOST_ADMISSION_ACTION_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, parseApprovalReplyMetadata, parseApprovalRequestMetadata, parseSessionRule, redactSecrets, } from '@canonmsg/core';
 export { SessionManager } from './session-manager.js';
 export { DEFAULT_ANTHROPIC_REQUEST_HEADROOM_BYTES, DEFAULT_MEDIA_CACHE_DIR, DEFAULT_MEDIA_MATERIALIZATION_BYTES, MAX_ANTHROPIC_IMAGE_RAW_BYTES, MAX_ANTHROPIC_REQUEST_BYTES, MAX_CANON_MEDIA_BYTES, getCodexImagePath, getMessageAttachments, inferUploadMimeType, isAnthropicImageAttachment, materializeAttachment, materializeMessageMedia, materializeReplyContextMedia, resolveAttachmentMimeType, sendMediaFileMessage, toAnthropicImageBlock, toAnthropicImageBlocksWithinBudget, uploadMediaFile, } from './media.js';
+export { createCanonAttachedSession, createCanonAttachedSessionPublisher } from './attached-session.js';
+export { createCanonWorkSessionHost } from './work-session-host.js';
+export { createFileWorkSessionHostStore } from './work-session-state.js';
+export { createFileAttachedSessionStore } from '@canonmsg/core';

package/dist/work-session-host.d.ts

@@ -0,0 +1,31 @@
+import { type AttachedSessionBinding, type AttachedSessionStore, type NativeWorkSessionProvider } from '@canonmsg/core';
+import { type CanonAttachedSessionConnection, type CanonAttachedSessionStatus } from './attached-session.js';
+import { type WorkSessionHostStore } from './work-session-state.js';
+export interface CanonWorkSessionHostOptions {
+    connection: CanonAttachedSessionConnection;
+    /** Stable installation identity. A new random runtime epoch is used each start. */
+    hostId: string;
+    displayName: string;
+    provider: NativeWorkSessionProvider;
+    store: WorkSessionHostStore;
+    createSessionStore(binding: AttachedSessionBinding): AttachedSessionStore;
+    /** Process-wide native audience lock, shared with any standalone attachment CLI. */
+    acquireNativeSession(binding: AttachedSessionBinding): (() => void) | Promise<() => void>;
+    onStatus?: (event: {
+        status: 'available' | 'stopped' | 'session';
+        conversationId?: string;
+        session?: CanonAttachedSessionStatus;
+    }) => void;
+    onError?: (error: unknown, operation: string) => void;
+    pollIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    connectTimeoutMs?: number;
+}
+export interface CanonWorkSessionHost {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Refresh discovery and process one durable request; serialized with the poll loop. */
+    reconcile(): Promise<void>;
+}
+/** One authenticated transport and liveness publisher, with durable per-room native routes. */
+export declare function createCanonWorkSessionHost(options: CanonWorkSessionHostOptions): CanonWorkSessionHost;