@canonmsg/agent-sdk 11.2.1 → 12.1.0

package/dist/types.d.ts

@@ -1,387 +0,0 @@
-export type { AddMemberResult, AgentClientType, CanonGroupContext, CanonRuntimeActivityItem, CanonRuntimeActivityKind, CanonRuntimeActivityStatus, CanonRuntimeDescriptor, CanonRuntimeFact, CanonRuntimeFactGroup, CanonRuntimePrimitiveId, CanonRuntimeProvenance, CanonTurnContextV2, CanonMessage, CanonConversation, CommunicateInput, CommunicateResult, CanonReplyContext, CanonContact, CanonResolveAdmissionResult, ContactAddedPayload, ContactRemovedPayload, ContactSource, AgentContext, ResolveAdmissionTargetInput, ResolvedAdmissionState, ResolvedAdmissionTargetSummary, ResolvedTargetAdmissionPayload, CanonSelfContext, CreateGroupOptions, CreateGroupResult, SendMessageOptions, TurnLifecycleState, TurnOutputBlock, TurnOutputBlockInput, ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRequestMetadata, ApprovalRisk, ApprovalReplyMetadata, ApprovalOutcomeMetadata, RuntimeInputChoice, RuntimeInputAnswers, RuntimeInputKind, RuntimeInputNativeMetadata, RuntimeInputQuestion, RuntimePlanRequestPayload, RuntimePlanRequestResult, RuntimeCardNativeMetadata, RuntimeCardV1, ResumableMediaUploadResult, MediaAttachment, VideoProcessingStatus, VideoProcessingErrorCode, SessionRule, ApprovalResult, } from '@canonmsg/core';
-import type { AddMemberResult, CanonGroupContext, CanonMessage, CanonConversation, CommunicateInput, CommunicateResult, CanonReplyContext, CanonRuntimeActionDispatch, CanonRuntimePrimitiveId, CanonRuntimeProvenance, CanonTurnContextV2, ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalResult, ApprovalRisk, RuntimeInputChoice, RuntimeInputAnswers, RuntimeInputKind, RuntimeInputNativeMetadata, RuntimeInputQuestion, RuntimePlanRequestPayload, RuntimePlanRequestResult, RuntimeCardNativeMetadata, RuntimeCardV1, ResumableMediaUploadResult, SendMessageOptions, TurnOutputBlock, TurnOutputBlockInput } from '@canonmsg/core';
-import type { MaterializeMediaOptions, MaterializedCanonAttachment, ReplyWithFileOptions, UploadMediaFileOptions } from './media.js';
-export interface ProgressMessageOptions extends SendMessageOptions {
-    /**
-     * Persist the progress update to Firestore.
-     * By default, progress stays ephemeral and only updates the live RTDB turn state.
-     */
-    durable?: boolean;
-}
-/**
- * Result of a durable reply.
- *
- * Text over Canon's 4 KB (UTF-8) message limit is delivered as ordered chunks
- * rather than refused, so one `replyFinal` can land as more than one message.
- * `messageId` is the last one — the message carrying `turn_complete` and the
- * turn trail — and `messageIds` lists every part in order (a single entry when
- * the text fit, which is the common case).
- */
-export interface FinalMessageResult {
-    messageId: string;
-    messageIds: string[];
-}
-export type ProgressMessageResult = {
-    turnId: string;
-    durable: false;
-    messageId: null;
-} | {
-    turnId: string;
-    durable: true;
-    messageId: string;
-    /**
-     * Every message the update landed as, in order. A durable update over
-     * Canon's 4 KB (UTF-8) limit is split into ordered parts rather than
-     * refused; `messageId` is the last of them. One entry when the text fit,
-     * which is the common case.
-     */
-    messageIds: string[];
-};
-export interface SessionInfo {
-    /** Session ID (= conversationId) */
-    id: string;
-    /** All accumulated messages for this conversation (within the context limit), oldest first */
-    messages: CanonMessage[];
-    /** Arbitrary per-session state the agent can read/write across handler calls */
-    metadata: Record<string, unknown>;
-    queueDepth?: number;
-}
-export interface TurnController {
-    id: string;
-    state: import('@canonmsg/core').TurnLifecycleState;
-    setThinking: (text?: string) => Promise<void>;
-    setStreaming: (text: string) => Promise<void>;
-    appendDelta: (delta: string) => void;
-    appendBlock: (block: string) => void;
-    appendTextSegmentDelta: (id: string, delta: string) => void;
-    replaceTextSegmentSnapshot: (id: string, text: string) => void;
-    addBlock: (block: TurnOutputBlockInput) => Promise<TurnOutputBlock>;
-    updateBlock: (id: string, patch: Partial<Omit<TurnOutputBlockInput, 'id' | 'sequence'>>) => Promise<TurnOutputBlock | null>;
-    completeBlock: (id: string, patch?: Partial<Omit<TurnOutputBlockInput, 'id' | 'sequence' | 'status'>>) => Promise<TurnOutputBlock | null>;
-    failBlock: (id: string, patch?: Partial<Omit<TurnOutputBlockInput, 'id' | 'sequence' | 'status'>>) => Promise<TurnOutputBlock | null>;
-    replaceSnapshot: (text: string) => Promise<void>;
-    flush: () => Promise<void>;
-    clear: () => Promise<void>;
-    /**
-     * End this turn without posting anything (`canon.verbs.v1` `no_reply`). The
-     * live bubble is blanked and removed instead of being salvaged into a durable
-     * message, so nothing is rendered and no other member or agent is triggered —
-     * the agent-turn trigger is message-driven.
-     *
-     * `reason` is private: the text never leaves the process. Only its presence
-     * is reported (a fixed sentinel on the wire), so the durable silence record
-     * can set `hasReason` — the text itself is never sent and never rendered.
-     *
-     * Unlike the model-driven runtimes, this does NOT gate `replyFinal`. Calling
-     * both is two explicit decisions by the same author, so the text still lands;
-     * call `noReply` when the handler has decided not to answer at all.
-     */
-    noReply: (reason?: string) => Promise<void>;
-    setTool: (text: string) => Promise<void>;
-    setWaitingInput: (text?: string) => Promise<void>;
-}
-export interface RuntimeApprovalRequest {
-    /** Native runtime/tool/action name that is asking for permission. */
-    toolName: string;
-    /** Structured native input. Raw values are summarized/redacted before storage. */
-    toolInput?: Record<string, unknown>;
-    /** Optional pre-redacted summary when a runtime already has user-facing copy. */
-    toolSummary?: string;
-    category?: ApprovalRequestCategory;
-    risk?: ApprovalRisk;
-    riskLevel?: 'normal' | 'destructive';
-    runtimeId?: string;
-    turnId?: string;
-    native?: ApprovalNativeRequestMetadata;
-    details?: ApprovalRequestDetail[];
-    /** Human conversation member who should answer. Defaults to the triggering human. */
-    responseUserId?: string;
-    /** Aborts the Canon approval request and withdraws its pending card. */
-    signal?: AbortSignal;
-    /**
-     * Ignore in-memory session rules for this approval request. Useful when the
-     * action was triggered by someone other than the agent owner.
-     */
-    ignoreSessionRules?: boolean;
-    /** Whether an approval reply may set an in-memory session rule. */
-    allowSessionRule?: boolean;
-}
-export interface RuntimeInputRequest {
-    kind: RuntimeInputKind;
-    title: string;
-    prompt: string;
-    choices?: RuntimeInputChoice[];
-    questions?: RuntimeInputQuestion[];
-    secretName?: string;
-    sensitive?: boolean;
-    runtimeId?: string;
-    turnId?: string;
-    native?: RuntimeInputNativeMetadata;
-    inputId?: string;
-    timeoutMs?: number;
-    /** Aborts the pending input request without waiting for the enclosing turn to stop. */
-    signal?: AbortSignal;
-    /** Human conversation member who should answer. Secret and sudo prompts remain owner-only. */
-    responseUserId?: string;
-}
-export interface RuntimeInputResult {
-    status: 'submitted' | 'cancelled' | 'timeout';
-    value?: string;
-    answers?: RuntimeInputAnswers;
-    inputId: string;
-}
-/** Native Canon plan-review card backed by Core's existing runtime-plan interaction. */
-export interface RuntimePlanReviewRequest extends RuntimePlanRequestPayload {
-    planId?: string;
-    timeoutMs?: number;
-    /** Aborts the pending plan review without waiting for the enclosing turn to stop. */
-    signal?: AbortSignal;
-}
-export type RuntimePlanReviewResult = RuntimePlanRequestResult;
-export interface RuntimeCardRequest {
-    card: RuntimeCardV1;
-    cardId?: string;
-    expiresAt?: string | number | Date;
-    /** Human conversation member who should answer. Defaults to the triggering human. */
-    responseUserId?: string;
-    timeoutMs?: number;
-    runtimeId?: string;
-    turnId?: string;
-    native?: RuntimeCardNativeMetadata;
-}
-export interface RuntimeCardResult {
-    status: 'submitted' | 'cancelled' | 'timeout' | 'displayed';
-    cardId: string;
-    actionId?: string;
-    values?: Record<string, unknown>;
-    /** Canon-authenticated human who submitted this card response. */
-    respondedBy?: string;
-}
-export interface MessageHandlerContext {
-    messages: CanonMessage[];
-    history: CanonMessage[];
-    /** Resolved message/media content for the latest swipe-reply target, if any. */
-    replyContext: CanonReplyContext | null;
-    conversationId: string;
-    conversation: CanonConversation;
-    /** Lightweight group awareness, present for group conversations. */
-    groupContext?: CanonGroupContext;
-    replyFinal: (text: string, options?: SendMessageOptions, delivery?: {
-        operationId?: string;
-        replacesOperationId?: string;
-    }) => Promise<FinalMessageResult>;
-    /** Inspect a prior reply before renewing media or recording product completion. */
-    getReplyOperation: (messageId: string, delivery?: {
-        operationId?: string;
-    }) => Promise<import('@canonmsg/core').CanonMessageOperation | undefined>;
-    /** Reconcile every part of a journaled reply without rebuilding its content. */
-    waitForReply: (operationId: string) => Promise<FinalMessageResult>;
-    replyProgress: (text: string, options?: ProgressMessageOptions) => Promise<ProgressMessageResult>;
-    /** Soft-delete a message (agent must be the sender) */
-    deleteMessage: (messageId: string) => Promise<void>;
-    /** Mark conversation as read */
-    markAsRead: () => Promise<void>;
-    /** Leave this conversation */
-    leave: () => Promise<void>;
-    /** Toggle emoji reaction on a message */
-    react: (messageId: string, emoji: string) => Promise<void>;
-    /**
-     * Add a member to this conversation (requires owner/admin role).
-     * Returns `{ status: 'added' }` on immediate add, or
-     * `{ status: 'pending', requestId }` if the target requires approval —
-     * a contact-request (kind: 'group_invite') is created and the join
-     * lands when the approver accepts.
-     */
-    addMember: (userId: string) => Promise<AddMemberResult>;
-    /** Remove a member from this conversation (requires owner/admin role) */
-    removeMember: (userId: string) => Promise<void>;
-    /** Message an existing Canon conversation or start/continue a direct one. */
-    communicate: (input: CommunicateInput) => Promise<CommunicateResult>;
-    /** Trusted agent identity & access context */
-    agent: import('@canonmsg/core').AgentContext;
-    /** Active private self-context to continue for this turn, if Canon supplied one. */
-    activeSelfContextId: string | null;
-    /** Canon-provided private context explaining this agent's cross-session actions. */
-    selfContexts?: import('@canonmsg/core').CanonSelfContext[];
-    /** Trusted Canon provenance for the latest inbound message in this handler batch. */
-    provenance: CanonRuntimeProvenance;
-    /** Compact structured Canon turn context for the latest inbound message in this handler batch. */
-    turnContext: CanonTurnContextV2;
-    /**
-     * Each batched input's own shared-work references (the version it was
-     * about, `origin` and any selection), in batch order. Malformed references
-     * are dropped; an input with none is omitted.
-     */
-    artifactContexts: Array<{
-        messageId: string;
-        context: import('@canonmsg/core').ArtifactContext;
-    }>;
-    /**
-     * Shared work in this handler's conversation (chess, forms, images): exactly
-     * `CanonClient.artifacts(conversationId)`. Changes are made against the state
-     * this agent last read or wrote (across turns), so a person's newer edit is
-     * reported as a `CanonArtifactError` conflict instead of being overwritten:
-     * `describe()` before `update()` (or pass `basedOnRevisionId`); with no read
-     * yet, `update()` rejects with `NOT_READ`. Arrival reads nothing on the
-     * handler's behalf. Dev-only preview; other environments reject with
-     * `ARTIFACTS_UNAVAILABLE`.
-     */
-    readonly artifacts: import('@canonmsg/core').CanonConversationArtifacts;
-    /** Runtime turn mode requested by the sender for this inbound turn, if any. */
-    requestedTurnMode: string | null;
-    /**
-     * How much of this turn's middle the reader sees, already resolved from
-     * `CanonAgentOptions.turnVerbosity` and the conversation type — groups are
-     * quiet by default, DMs verbose. In `'quiet'` the SDK publishes no
-     * `/streaming` narration and attaches no turn trail to the final, so a
-     * handler can skip building either. It stays fixed for the whole turn.
-     */
-    turnVerbosity: import('@canonmsg/core').TurnVerbosity;
-    /**
-     * Ask the triggering human to approve a native runtime action. This only
-     * renders Canon's inline approval card; runtimes must explicitly wait for
-     * and enforce the returned decision in their own approval hook.
-     */
-    requestApproval: (request: RuntimeApprovalRequest) => Promise<ApprovalResult>;
-    /**
-     * Ask the triggering human for runtime input. Secret and sudo prompts remain
-     * owner-only. Sensitive values are returned only to the calling runtime and
-     * are never persisted in Canon message metadata.
-     */
-    requestRuntimeInput: (request: RuntimeInputRequest) => Promise<RuntimeInputResult>;
-    /**
-     * Present a native Canon plan-review card and wait for approve, revise,
-     * reject, cancellation, or timeout. Canon owns presentation and response
-     * routing; the runtime remains responsible for enforcing the decision.
-     */
-    requestPlanReview: (request: RuntimePlanReviewRequest) => Promise<RuntimePlanReviewResult>;
-    /**
-     * Ask the triggering human to review/respond to a generic rich card. The
-     * visible card document is redacted for presentation; raw response values
-     * return only to the calling runtime through Canon's control path.
-     */
-    requestCard: (request: RuntimeCardRequest) => Promise<RuntimeCardResult>;
-    /**
-     * Post a fire-and-forget display/report card and return immediately with
-     * `{ status: 'displayed' }` — no waiting-input lifecycle. Use requestCard for
-     * cards that expect a response. (requestCard also auto-detects action-less
-     * cards and delegates here.)
-     */
-    sendCard: (request: RuntimeCardRequest) => Promise<RuntimeCardResult>;
-    /** Canon-managed local media access for the current conversation. */
-    media: {
-        materialize: (message?: CanonMessage, options?: Omit<MaterializeMediaOptions, 'agentId' | 'conversationId' | 'messageId'>) => Promise<MaterializedCanonAttachment[]>;
-        uploadFile: (filePath: string, options?: UploadMediaFileOptions) => Promise<ResumableMediaUploadResult>;
-        replyWithFile: (filePath: string, text?: string, options?: ReplyWithFileOptions) => Promise<{
-            messageId: string;
-        }>;
-    };
-    /** Per-conversation session state. Present when sessions are enabled. */
-    session?: SessionInfo;
-    /** Turn lifecycle helpers for live-work rendering and progress reporting. */
-    turn?: TurnController;
-    /** Aborted when Canon sends an interrupt/stop signal for this active turn. */
-    abortSignal: AbortSignal;
-}
-export type MessageHandler = (ctx: MessageHandlerContext) => Promise<void>;
-export type MessageUpdatedHandler = (payload: import('@canonmsg/core').MessageUpdatedPayload) => void | Promise<void>;
-export interface SessionOptions {
-    /** Enable per-conversation session management (default: false) */
-    enabled: boolean;
-    /** Max messages retained per session (default: 50) */
-    contextLimit?: number;
-    /** Max sessions processing concurrently (default: 10) */
-    concurrency?: number;
-    /** Evict idle sessions after this many ms (default: 3600000 = 1h) */
-    idleTimeoutMs?: number;
-}
-export type DeliveryMode = 'auto' | 'sse';
-export type RuntimeSignalType = Extract<CanonRuntimeActionDispatch, {
-    kind: 'signal';
-}>['signal'];
-export interface RuntimeSignalContext {
-    conversationId: string;
-    signal: RuntimeSignalType;
-    updatedAt?: number;
-    abortSignal?: AbortSignal;
-    droppedMessageIds: string[];
-}
-export type RuntimeSignalHandler = (context: RuntimeSignalContext) => void | Promise<void>;
-export interface RuntimeControlHandlers {
-    onInterrupt?: RuntimeSignalHandler;
-    onStopAndDrop?: RuntimeSignalHandler;
-    onNewSession?: RuntimeSignalHandler;
-}
-export type RuntimeControlSurface = 'agent' | 'host';
-export interface RuntimePrimitiveContext {
-    conversationId: string;
-    primitive: CanonRuntimePrimitiveId;
-    args: Record<string, string | boolean>;
-    rawText?: string;
-    alias?: string;
-    requestId?: string;
-    updatedAt?: number;
-}
-export type RuntimePrimitiveHandler = (context: RuntimePrimitiveContext) => void | Promise<void>;
-export type RuntimePrimitiveHandlers = Partial<Record<CanonRuntimePrimitiveId, RuntimePrimitiveHandler>> & {
-    '*'?: RuntimePrimitiveHandler;
-};
-export interface CanonAgentConnectionOptions {
-    /** Canon trust domain for API, stream, RTDB, and future cryptographic state. */
-    environmentId: import('@canonmsg/core').CanonEnvironmentId;
-    baseUrl?: string;
-    streamUrl?: string;
-    rtdbUrl?: string;
-    /** Legacy Firebase connection option; endpoint-backed runtime state does not use it. */
-    firebaseApiKey?: string;
-}
-export interface CanonAgentOptions extends CanonAgentConnectionOptions {
-    /** Shared durable engine or persistent installation profile for this runtime. */
-    endpoint?: import('@canonmsg/core').CanonClientEndpointOptions;
-    apiKey: string;
-    /** `auto` resolves to SSE. */
-    deliveryMode?: DeliveryMode;
-    debounceMs?: number;
-    historyLimit?: number;
-    /** Automatically mark conversations as read when handling messages (default: true) */
-    autoMarkRead?: boolean;
-    /** Per-conversation session management */
-    sessions?: SessionOptions;
-    /** Agent client type for capability detection. Defaults to 'generic'. */
-    clientType?: import('@canonmsg/core').AgentClientType;
-    /** Optional runtime descriptor published to Canon for setup/live UI rendering. */
-    runtimeDescriptor?: import('@canonmsg/core').CanonRuntimeDescriptor;
-    /** Optional Canon runtime signal handlers. Enables interrupt controls when provided. */
-    runtimeControls?: RuntimeControlHandlers;
-    /** Runtime publishing surface. Use `host` when this agent owns live runtime controls. */
-    runtimeControlSurface?: RuntimeControlSurface;
-    /** Optional typed runtime primitive handlers. Enables descriptor-backed command controls when provided. */
-    runtimePrimitives?: RuntimePrimitiveHandlers;
-    /**
-     * Enable canonical agent-session state reporting. Off by default.
-     * Turn-state reporting is automatic while handlers run.
-     */
-    sessionState?: boolean;
-    /**
-     * How much of a turn's middle the reader sees. Unset (or `'auto'`) resolves
-     * per turn from the conversation type: DMs verbose, groups quiet. A scalar
-     * overrides everywhere; the object form overrides one conversation type and
-     * leaves the other on its default.
-     *
-     * `'quiet'` drops the live `/streaming` narration and the final's margin
-     * turn trail. It never touches the typing indicator, the turn state, the
-     * final message, failure notices, or interaction cards and their receipts —
-     * and an explicit `ctx.replyProgress(text, { durable: true })` still posts,
-     * because a developer's explicit send is not runtime narration.
-     */
-    turnVerbosity?: import('./turn-verbosity-option.js').CanonAgentTurnVerbosityOption;
-}
-export type ContactAddedHandler = (contact: import('@canonmsg/core').ContactAddedPayload) => void | Promise<void>;
-export type ContactRemovedHandler = (payload: import('@canonmsg/core').ContactRemovedPayload) => void | Promise<void>;
-/**
- * Observe-only notice that the participation gate suppressed a turn this
- * agent would otherwise have been dispatched (cap reached, mention required,
- * agent-to-agent disabled). Never run a turn off this event — it exists so a
- * benched agent can tell deliberate participation policy from a dead stream.
- */
-export type ParticipationSuppressedHandler = (payload: import('@canonmsg/core').ParticipationSuppressedPayload) => void | Promise<void>;

package/dist/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,21 +0,0 @@
-import { CanonClient, type WorkSessionCatalog, type WorkSessionCompletion, type WorkSessionRequest, type WorkSessionRuntimeAuth, type WorkSessionRuntimeState } from '@canonmsg/core';
-import type { WorkSessionJournal } from './work-session-state.js';
-/** The same request identity is used by native creation and managed setup recovery. */
-export declare function fingerprintWorkSessionRequest(request: WorkSessionRequest): string;
-/** Shared broker authority; each host retains its own delivery and request dispatch loop. */
-export declare function createWorkSessionAuthority(options: {
-    client: CanonClient;
-    hostId: string;
-    runtimeEpoch: string;
-    displayName: string;
-    isStopped(): boolean;
-}): {
-    auth: () => WorkSessionRuntimeAuth;
-    fence: () => void;
-    retain: (state: WorkSessionRuntimeState) => WorkSessionRuntimeState;
-    register: (catalog: WorkSessionCatalog) => Promise<WorkSessionRuntimeState>;
-    heartbeat: (catalog: WorkSessionCatalog) => Promise<WorkSessionRuntimeState>;
-    claim: (requestId?: string) => Promise<import("@canonmsg/backend-contracts").WorkSessionClaimResult>;
-    acknowledge: (journal: WorkSessionJournal, requestId: string, result: WorkSessionCompletion) => Promise<WorkSessionRequest>;
-    state: () => WorkSessionRuntimeState | undefined;
-};

package/dist/work-session-coordination.js

@@ -1,53 +0,0 @@
-import { createHash } from 'node:crypto';
-/** The same request identity is used by native creation and managed setup recovery. */
-export function fingerprintWorkSessionRequest(request) {
-    return createHash('sha256').update(JSON.stringify([
-        request.agentId, request.conversationId, request.requestId, request.hostId,
-        request.runtimeEpoch, request.catalogRevision, request.selection, request.requestedBy,
-    ])).digest('hex');
-}
-/** Shared broker authority; each host retains its own delivery and request dispatch loop. */
-export function createWorkSessionAuthority(options) {
-    let current;
-    function auth() {
-        if (!current)
-            throw new Error('Work-session runtime is not registered.');
-        return { hostId: options.hostId, runtimeEpoch: options.runtimeEpoch,
-            leaseToken: current.lease.leaseToken };
-    }
-    function fence() {
-        if (options.isStopped() || !current || current.lease.expiresAt - Date.now() < 5_000)
-            throw new Error('Work-session runtime no longer has a fresh lease.');
-    }
-    function retain(state) {
-        if (state.lease.hostId !== options.hostId || state.lease.runtimeEpoch !== options.runtimeEpoch
-            || (current && current.ownerId !== state.ownerId))
-            throw new Error('Work-session runtime identity changed.');
-        current = state;
-        return state;
-    }
-    async function register(catalog) {
-        return retain(await options.client.registerWorkSessionRuntime({ hostId: options.hostId,
-            runtimeEpoch: options.runtimeEpoch, displayName: options.displayName, catalog }));
-    }
-    async function heartbeat(catalog) {
-        fence();
-        return retain(await options.client.heartbeatWorkSessionRuntime({ ...auth(), catalog }));
-    }
-    function claim(requestId) {
-        fence();
-        return options.client.claimWorkSessionRequest({ ...auth(), ...(requestId ? { requestId } : {}) });
-    }
-    async function acknowledge(journal, requestId, result) {
-        fence();
-        const completed = await options.client.completeWorkSessionRequest({ ...auth(), requestId, result });
-        if (completed.status !== result.status)
-            throw new Error('Canon did not acknowledge the requested work-session outcome.');
-        await journal.mutate((state) => {
-            state.operations.find((entry) => entry.request.requestId === requestId).acknowledged = true;
-        });
-        return completed;
-    }
-    return { auth, fence, retain, register, heartbeat, claim, acknowledge,
-        state: () => current };
-}

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

@@ -1,31 +0,0 @@
-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;