@canonmsg/agent-sdk 12.0.0 → 12.1.0

package/dist/internal/backend-contracts/mlsDevInteraction.d.ts

@@ -0,0 +1,159 @@
+import { type MlsDevInteractionBinding, type MlsDevInteractionKind, type MlsDevItemPayload, type MlsDevTextPayload } from './mlsDevApplication.js';
+import { type MlsDevGroupHead } from './mlsDevGroup.js';
+/**
+ * Encrypted approvals and questions in `canon.mls.dev-text.v2` rooms (docs/design/encrypted-interactions.md §2.3–§2.4).
+ * The MLS plaintext is a closed union on `kind`; every variant carries the text payload's shared ids. These parsers run
+ * in the sender's endpoint before encryption and in every recipient after decryption. Native custody treats an
+ * interaction body as canonical JSON and checks only the shared ids, kind and size.
+ */
+export declare const MLS_DEV_INTERACTION_LIMITS: Readonly<{
+    title: 200;
+    details: 8000;
+    options: 10;
+    optionLabel: 120;
+    text: 4000;
+}>;
+/** RFC 9180 base mode, DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-128-GCM: MLS suite 1's primitives. */
+export declare const MLS_DEV_SECRET_ANSWER_SUITE: "x25519-hkdf-sha256-aes128gcm";
+/** UTF-8 of at most 4,000 code points (4 bytes each) plus the AES-GCM tag. */
+export declare const MLS_DEV_SECRET_ANSWER_MAX_BYTES: number;
+export declare const MLS_DEV_INTERACTION_WITHDRAW_REASONS: readonly ["stopped", "turn_ended", "expired", "restart"];
+export type MlsDevInteractionWithdrawReason = typeof MLS_DEV_INTERACTION_WITHDRAW_REASONS[number];
+export interface MlsDevInteractionOption {
+    readonly id: string;
+    readonly label: string;
+}
+export interface MlsDevInteractionRequestBody {
+    readonly requestId: string;
+    readonly kind: MlsDevInteractionKind;
+    readonly title: string;
+    readonly details?: string;
+    readonly options?: readonly MlsDevInteractionOption[];
+    readonly multiple?: boolean;
+    readonly risk?: 'normal' | 'destructive';
+    readonly allowSession?: boolean;
+    readonly scopeKey?: string;
+    readonly responderIds: readonly [string];
+    readonly expiresAtMs: number;
+    /** A secret request's one-time HPKE recipient key, generated and held by the requesting device's custody (§2.5). */
+    readonly secretKey?: {
+        readonly kem: 'x25519';
+        readonly publicKey: string;
+    };
+}
+export type MlsDevInteractionAnswer = {
+    readonly decision: 'allow' | 'deny';
+    readonly scope: 'once' | 'session';
+} | {
+    readonly choices: readonly string[];
+} | {
+    readonly text: string;
+} | {
+    readonly sealed: {
+        readonly enc: string;
+        readonly ciphertext: string;
+    };
+}
+/** The responder's Cancel/Skip on a question or secret card (review of #1081). */
+ | {
+    readonly cancelled: true;
+};
+export interface MlsDevInteractionResponseBody {
+    readonly requestId: string;
+    readonly agentId: string;
+    readonly answer: MlsDevInteractionAnswer;
+}
+export interface MlsDevInteractionWithdrawBody {
+    readonly requestId: string;
+    readonly reason: MlsDevInteractionWithdrawReason;
+}
+interface MlsDevApplicationPayloadIds {
+    readonly version: 1;
+    readonly conversationId: string;
+    readonly groupId: string;
+    readonly messageId: string;
+    readonly operationId: string;
+    readonly senderDeviceId: string;
+}
+export type MlsDevInteractionPayload = (MlsDevApplicationPayloadIds & {
+    readonly kind: 'interaction.request';
+    readonly interaction: MlsDevInteractionRequestBody;
+}) | (MlsDevApplicationPayloadIds & {
+    readonly kind: 'interaction.response';
+    readonly interaction: MlsDevInteractionResponseBody;
+}) | (MlsDevApplicationPayloadIds & {
+    readonly kind: 'interaction.withdraw';
+    readonly interaction: MlsDevInteractionWithdrawBody;
+});
+export type MlsDevApplicationPayload = MlsDevTextPayload | MlsDevItemPayload | MlsDevInteractionPayload;
+export type MlsDevInteractionPayloadKind = MlsDevInteractionPayload['kind'];
+export declare const MLS_DEV_INTERACTION_PAYLOAD_KINDS: readonly ["interaction.request", "interaction.response", "interaction.withdraw"];
+/** The server's metadata-only record (§2.4): no title, options, decision, scope or answer. */
+export interface MlsDevInteractionRecord {
+    readonly version: 1;
+    readonly conversationId: string;
+    readonly agentId: string;
+    readonly requesterDeviceId: string;
+    readonly requestId: string;
+    readonly kind: MlsDevInteractionKind;
+    readonly responderIds: readonly [string];
+    readonly expiresAtMs: number;
+    readonly status: 'pending' | 'answered' | 'withdrawn';
+    readonly binding: {
+        readonly groupId: string;
+        readonly head: MlsDevGroupHead;
+        readonly membershipRevision: number;
+        readonly requestMessageId: string;
+        readonly requestOrdinal: number;
+    };
+    readonly answer?: {
+        readonly responderId: string;
+        readonly responderDeviceId: string;
+        readonly messageId: string;
+        readonly ordinal: number;
+        readonly acceptedAtMs: number;
+    };
+    readonly withdrawal?: {
+        readonly messageId: string;
+        readonly ordinal: number;
+        readonly acceptedAtMs: number;
+    };
+    readonly createdAtMs: number;
+}
+export interface MlsDevInteractionsQuery {
+    readonly version: 1;
+    readonly conversationId?: string;
+}
+/** The caller's answerable pending requests, for badges and web's content-free waiting notice. */
+export interface MlsDevInteractionsResult {
+    readonly version: 1;
+    readonly interactions: readonly {
+        readonly conversationId: string;
+        readonly agentId: string;
+        readonly requestId: string;
+        readonly kind: MlsDevInteractionKind;
+        readonly expiresAtMs: number;
+    }[];
+}
+export declare const MLS_DEV_INTERACTIONS_QUERY_MAX = 50;
+export declare class MlsDevInteractionValidationError extends Error {
+    readonly code = "INVALID_MLS_DEV_INTERACTION";
+    constructor();
+}
+export declare function parseMlsDevInteractionRequestBody(value: unknown): MlsDevInteractionRequestBody;
+export declare function parseMlsDevInteractionAnswer(value: unknown): MlsDevInteractionAnswer;
+export declare function parseMlsDevInteractionResponseBody(value: unknown): MlsDevInteractionResponseBody;
+export declare function parseMlsDevInteractionWithdrawBody(value: unknown): MlsDevInteractionWithdrawBody;
+/** The closed v2 plaintext union. A v1 room accepts only `kind: 'text'` (`parseMlsDevTextPayload`). */
+export declare function parseMlsDevApplicationPayload(value: unknown): MlsDevApplicationPayload;
+/** Receipt-time check (`applyApplication`): the encrypted payload repeats exactly what its public binding announced. */
+export declare function assertMlsDevInteractionPayloadBinding(payload: MlsDevApplicationPayload, binding: MlsDevInteractionBinding | undefined): void;
+/**
+ * Whether an answer has the shape its request allows. A session-scoped decision needs a request that offered a session
+ * rule (`allowSession`; a destructive action never does, §3); the runner also counts one only from the agent's owner.
+ */
+export declare function isMlsDevInteractionAnswerAllowed(request: MlsDevInteractionRequestBody, answer: MlsDevInteractionAnswer): boolean;
+export declare function parseMlsDevInteractionRecord(value: unknown): MlsDevInteractionRecord;
+export declare function parseMlsDevInteractionsQuery(value: unknown): MlsDevInteractionsQuery;
+export declare function parseMlsDevInteractionsResult(value: unknown): MlsDevInteractionsResult;
+export {};

package/dist/internal/backend-contracts/mlsEnvironment.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Each environment's MLS identity: the values signed into its credentials, group controls and application AAD. A
+ * production device, credential or group can never verify as Dev (or the reverse) because these differ. Dev's values
+ * are today's literals, so Dev bytes are unchanged. A declared profile only defines the wire; whether an environment
+ * runs MLS is decided by its deployment (Functions gates, configuration, native builds), never here.
+ */
+export declare const MLS_ENVIRONMENT_PROFILES: Readonly<{
+    readonly 'canon-dev-v1': Readonly<{
+        issuer: "canon-mls-dev-v1";
+        credentialType: "canon-mls-dev-credential+jws";
+        issuerKeyPath: "projects/canonmail-dev/locations/europe-west1/keyRings/canon-mls/cryptoKeys/device-issuer";
+        receiptKeyPath: "projects/canonmail-dev/locations/europe-west1/keyRings/canon-mls/cryptoKeys/feed-receipt";
+    }>;
+    readonly 'canon-prod-v1': Readonly<{
+        issuer: "canon-mls-prod-v1";
+        credentialType: "canon-mls-prod-credential+jws";
+        issuerKeyPath: "projects/canonmail-prod/locations/europe-west1/keyRings/canon-mls/cryptoKeys/device-issuer";
+        receiptKeyPath: "projects/canonmail-prod/locations/europe-west1/keyRings/canon-mls/cryptoKeys/feed-receipt";
+    }>;
+}>;
+export type MlsEnvironmentId = keyof typeof MLS_ENVIRONMENT_PROFILES;
+export type MlsEnvironmentProfile = (typeof MLS_ENVIRONMENT_PROFILES)[MlsEnvironmentId];
+export type MlsIssuerId = MlsEnvironmentProfile['issuer'];
+/**
+ * Exact match only: no trimming or case folding, so an alias never reaches signed bytes. Throws the shared internal
+ * parser error, which each public boundary replaces with its own.
+ */
+export declare function requireMlsEnvironmentId(value: unknown): MlsEnvironmentId;
+/** The same exact match as a predicate, for callers that refuse with their own error. */
+export declare function isMlsEnvironmentId(value: unknown): value is MlsEnvironmentId;
+export declare function mlsEnvironmentProfile(environmentId: MlsEnvironmentId): MlsEnvironmentProfile;
+/** The environment whose issuer key a KMS key-version path names, or undefined for any other path. */
+export declare function mlsEnvironmentOfIssuerKeyVersion(value: string): MlsEnvironmentId | undefined;
+/** The environment whose feed-receipt key (mls-signed-acceptance.md) a KMS key-version path names, or undefined. */
+export declare function mlsEnvironmentOfReceiptKeyVersion(value: string): MlsEnvironmentId | undefined;

package/dist/internal/backend-contracts/mlsPrincipalAlias.d.ts

@@ -0,0 +1,23 @@
+import { type MlsEnvironmentId } from './mlsEnvironment.js';
+export declare const MLS_PRINCIPAL_ALIAS_PREFIX = "mlsa_";
+export interface MlsPrincipalOpening {
+    readonly type: 'human' | 'ai_agent';
+    readonly accountId: string;
+    /** 32 random bytes, canonical base64url. */
+    readonly salt: string;
+}
+/** An alias's shape; whether it opens to an account needs its opening. Account IDs never have it. */
+export declare function isMlsPrincipalAlias(value: unknown): value is string;
+export declare function parseMlsPrincipalOpening(value: unknown): MlsPrincipalOpening;
+/**
+ * SHA-256 over the domain above, LP environment, u8 type (human 0/agent 1), LP account ID and the raw 32-byte salt,
+ * where LP is a u32 big-endian byte length followed by UTF-8, as in the enrollment proof.
+ */
+export declare function encodeMlsPrincipalAliasInput(environmentId: MlsEnvironmentId, opening: MlsPrincipalOpening): Uint8Array;
+export declare function mlsPrincipalAlias(environmentId: MlsEnvironmentId, opening: MlsPrincipalOpening): Promise<string>;
+/** Whether `opening` opens `alias` in this environment. A malformed opening opens nothing. */
+export declare function opensMlsPrincipalAlias(environmentId: MlsEnvironmentId, alias: string, opening: unknown): Promise<boolean>;
+/** A fresh opening for an account: Canon's server makes one the first time the account needs an alias. */
+export declare function createMlsPrincipalOpening(type: MlsPrincipalOpening['type'], id: string): MlsPrincipalOpening;
+/** A room's openings, `{[alias]: opening}`: the shape only. Readers still check each opening against its alias. */
+export declare function parseMlsRoomIdentities(value: unknown): Readonly<Record<string, MlsPrincipalOpening>>;

package/dist/internal/backend-contracts/runtimeCardFields.d.ts

@@ -4,8 +4,8 @@
  * type cannot drift.
  *
  * ORDER IS LOAD-BEARING: scripts/generate-skill-bundles.mjs renders this list
- * verbatim (via @canonmsg/rich-cards) into two committed SKILL.md files, and
- * `npm run check:skill-bundles` fails on a byte change.
+ * verbatim (via @canonmsg/rich-cards) into the Hermes plugin's committed
+ * rich-cards SKILL.md, and `npm run check:skill-bundles` fails on a byte change.
  */
 export declare const RUNTIME_CARD_FIELD_TYPES: readonly ["text", "textarea", "select", "multiSelect", "boolean", "date", "number", "currency", "searchSelect", "lineItems"];
 export type RuntimeCardFieldType = (typeof RUNTIME_CARD_FIELD_TYPES)[number];

package/dist/internal/backend-contracts/upload-mime-types.d.ts

@@ -0,0 +1,17 @@
+/** The media types Canon accepts for an upload, resolved the same way on a device and on the server. */
+export type AllowedUploadKind = 'image' | 'audio' | 'video' | 'file';
+export declare const SAFE_IMAGE_MIME_TYPES: Set<string>;
+export declare const SAFE_AUDIO_MIME_TYPES: Set<string>;
+export declare const SAFE_VIDEO_MIME_TYPES: Set<string>;
+export declare const SAFE_FILE_MIME_TYPES: Set<string>;
+export declare function normalizeMimeType(value: unknown): string | null;
+export declare function classifyAllowedUploadMimeType(value: unknown): AllowedUploadKind | null;
+export declare function normalizeAllowedUploadMimeType(value: unknown): string | null;
+export declare function resolveAllowedUploadMimeType(input: {
+    mimeType?: unknown;
+    fileName?: unknown;
+}): string | null;
+export declare function getAllowedUploadExtension(input: {
+    mimeType: string;
+    fileName?: unknown;
+}): string;

package/dist/internal/backend-contracts/verbContract.d.ts

@@ -51,8 +51,7 @@ export declare const CANON_VERB_NAMESPACE = "canon";
 /**
  * $id of the canonical canon.card.v1 document schema
  * (@canonmsg/rich-cards RUNTIME_CARD_JSON_SCHEMA_V1). The verbs bundle only
- * validates the card ENVELOPE; compose the full document schema into card
- * verbs via `getVerbInputSchema(verb, { cardSchema })`.
+ * validates the card ENVELOPE.
  */
 export declare const CANON_CARD_SCHEMA_ID = "https://canonmsg.com/schemas/canon.card.v1.json";
 /**
@@ -308,14 +307,23 @@ export type SendToResult = {
     created?: boolean;
     reused?: boolean;
     sessionSelection?: string;
+}
+/** The room is encrypted, so Canon stored no opening text: the sender sends it encrypted under `messageId`. */
+ | {
+    status: 'opened';
+    conversationId: string;
+    messageId: string;
+    openingText: 'deferred';
+    created?: boolean;
+    reused?: boolean;
 } | {
-    status: 'requested';
-    requestId: string | null;
-    deferredIntentId?: string | null;
-} | {
-    status: 'pending';
+    status: 'requested' | 'pending';
     requestId: string | null;
     deferredIntentId?: string | null;
+    /** An encrypted room stores no opener: the sender sends it into `conversationId` under `messageId`. */
+    conversationId?: string;
+    messageId?: string;
+    openingText?: 'deferred';
 } | {
     status: 'setup_required';
     reason: string;

package/dist/internal/backend-contracts/verbSchemas.d.ts

@@ -714,6 +714,31 @@ export declare const CANON_VERBS_JSON_SCHEMA: {
                         readonly type: "string";
                     };
                 };
+            }, {
+                readonly type: "object";
+                readonly required: readonly ["status", "conversationId", "messageId", "openingText"];
+                readonly additionalProperties: true;
+                readonly description: "The room is encrypted, so Canon stored no opening text: the sender sends it encrypted under messageId.";
+                readonly properties: {
+                    readonly status: {
+                        readonly const: "opened";
+                    };
+                    readonly conversationId: {
+                        readonly type: "string";
+                    };
+                    readonly messageId: {
+                        readonly type: "string";
+                    };
+                    readonly openingText: {
+                        readonly const: "deferred";
+                    };
+                    readonly created: {
+                        readonly type: "boolean";
+                    };
+                    readonly reused: {
+                        readonly type: "boolean";
+                    };
+                };
             }, {
                 readonly type: "object";
                 readonly required: readonly ["status", "requestId"];
@@ -729,6 +754,16 @@ export declare const CANON_VERBS_JSON_SCHEMA: {
                         readonly type: readonly ["string", "null"];
                         readonly description: "Present when the send is deferred until the contact request resolves.";
                     };
+                    readonly conversationId: {
+                        readonly type: "string";
+                    };
+                    readonly messageId: {
+                        readonly type: "string";
+                    };
+                    readonly openingText: {
+                        readonly const: "deferred";
+                        readonly description: "The room is encrypted, so Canon stored no opening text: the sender sends it encrypted under messageId.";
+                    };
                 };
             }, {
                 readonly type: "object";
@@ -1678,30 +1713,5 @@ export interface CanonVerbSchemaRefs {
 export declare const CANON_VERB_SCHEMA_REFS: Record<CanonVerbName, CanonVerbSchemaRefs>;
 /** A verb subschema extracted from the bundle, self-contained for embedding. */
 export type CanonVerbJsonSchema = Record<string, unknown>;
-export interface GetVerbSchemaOptions {
-    /**
-     * The full canon.card.v1 document schema (@canonmsg/rich-cards
-     * RUNTIME_CARD_JSON_SCHEMA_V1) to compose into card-carrying verbs. When
-     * provided, the envelope-only `runtimeCard` definition is replaced so block
-     * structures validate too. backend-contracts deliberately does not depend
-     * on rich-cards (build-order/dependency direction), so the binding supplies
-     * the schema.
-     *
-     * The card schema is REBASED, not nested: its own `$defs` are merged into
-     * the verb schema's `$defs` under `card__`-prefixed names and every
-     * internal `#/$defs/...` ref (including `<card $id>#/$defs/...` forms) is
-     * rewritten accordingly. The result is a single self-contained schema
-     * resource with plain internal refs — no embedded `$id` — so it compiles
-     * on naive validators and never conflicts with a separately registered
-     * canon.card.v1 resource on the same Ajv instance.
-     *
-     * Ajv note: the real card schema uses spec-valid union types
-     * (min/max: number | date-string), so compile composed schemas with
-     * `{ strict: true, allowUnionTypes: true }`.
-     */
-    cardSchema?: Record<string, unknown>;
-}
-/** Self-contained input schema for a verb (for embedding into tool definitions). */
-export declare function getVerbInputSchema(verb: CanonVerbName, options?: GetVerbSchemaOptions): CanonVerbJsonSchema;
 /** Self-contained result schema for a verb. */
 export declare function getVerbResultSchema(verb: CanonVerbName): CanonVerbJsonSchema;

package/dist/internal/core/agent-profiles.d.ts

@@ -1,10 +1,8 @@
 /**
  * Shared agent profile management — loading, locking, and resolution.
- * Used by both host.ts and server.ts.
  */
 import type { CanonEnvironmentId } from '../backend-contracts/index.js';
 import type { AgentClientType } from './types.js';
-import { type CanonRuntimeConnectionOptions } from './runtime-endpoints.js';
 export interface AgentProfileInput {
     apiKey: string;
     agentId: string;
@@ -64,6 +62,4 @@ export interface PendingRegistration {
 }
 export declare function loadPendingRegistrations(): Record<string, PendingRegistration>;
 export declare function savePendingRegistrations(pending: Record<string, PendingRegistration>): void;
-export declare function getOrCreatePendingRegistration(profile: string, clientType?: AgentClientType, connectionOptions?: CanonRuntimeConnectionOptions): PendingRegistration;
-export declare function updatePendingRegistration(profile: string, patch: Partial<Pick<PendingRegistration, 'requestId' | 'pollToken' | 'clientType'>>): PendingRegistration;
 export declare function clearPendingRegistration(profile: string): void;

package/dist/internal/core/approval-format.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRequestMetadata, ApprovalNativeRequestMetadata, ApprovalRisk, ApprovalReplyMetadata, SessionRule } from './approval-types.js';
+import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRequestMetadata, ApprovalNativeRequestMetadata, ApprovalRisk } from './approval-types.js';
 import type { CanonUnifiedDiff } from './types.js';
 export declare function generateApprovalId(): string;
 export declare function redactSecrets(text: string, patterns: string[]): string;
@@ -19,8 +19,4 @@ export declare function buildApprovalRequest(approvalId: string, toolName: strin
     text: string;
     metadata: ApprovalRequestMetadata;
 };
-export declare function buildApprovalReply(approvalId: string, decision: 'allow' | 'deny', sessionRule?: SessionRule): {
-    text: string;
-    metadata: ApprovalReplyMetadata;
-};
 export declare function buildApprovalOutcome(approvalId: string, toolName: string, toolSummary: string, decision: 'allow' | 'deny', reason: 'replied' | 'timeout' | 'session-rule'): string;

package/dist/internal/core/approval-types.d.ts

@@ -1,4 +1,4 @@
-import { type VerbNativeMetadata } from '../backend-contracts/index.js';
+import type { VerbNativeMetadata } from '../backend-contracts/index.js';
 import type { CanonUnifiedDiff } from './types.js';
 export interface ApprovalRequestMetadata {
     type: 'approval_request';
@@ -71,4 +71,3 @@ export interface ApprovalConfig {
 export declare const DEFAULT_APPROVAL_CONFIG: ApprovalConfig;
 export declare function parseSessionRule(value: unknown): SessionRule | null;
 export declare function parseApprovalReplyMetadata(value: unknown): ApprovalReplyMetadata | null;
-export declare function parseApprovalRequestMetadata(value: unknown): ApprovalRequestMetadata | null;

package/dist/internal/core/client.d.ts

@@ -1,14 +1,11 @@
-import { type CanonMessage, type CanonConversation, type CanonUnifiedDiff, type CanonContact, type CanonConversationsPage, type CanonConversationsPageOptions, type CanonMessagesPage, type CanonResolveAdmissionResult, type ResolveAdmissionTargetInput, type AppendMemoStreamChunkOptions, type CanonVoiceSession, type CanonVoiceSessionToken, type CreateMemoStreamOptions, type CreateMemoStreamResult, type CreateVoiceSessionOptions, type MemoStreamChunkAck, type AgentContext, type AddMemberResult, type CreateGroupResult, type MediaAttachment, type SendMessageOptions, type CreateGroupOptions, type JoinVoiceSessionOptions, type RegistrationStatus, type AgentOriginDeclaration, type SetRuntimeTurnOptions, type SetStreamingOptions, type UpdateAgentProfileOptions } from './types.js';
-import type { CanonGifSearchOptions, CanonGifSearchResponse } from './gifs.js';
+import { type CanonMessage, type CanonConversation, type CanonUnifiedDiff, type CanonContact, type CanonConversationsPage, type CanonConversationsPageOptions, type CanonMessagesPage, type CanonResolveAdmissionResult, type ResolveAdmissionTargetInput, type AppendMemoStreamChunkOptions, type CanonVoiceSession, type CanonVoiceSessionToken, type CreateMemoStreamOptions, type CreateMemoStreamResult, type CreateVoiceSessionOptions, type MemoStreamChunkAck, type AgentContext, type AddMemberResult, type CreateGroupResult, type MediaAttachment, type SendMessageOptions, type CreateGroupOptions, type JoinVoiceSessionOptions, type RegistrationStatus, type AgentOriginDeclaration, type SetRuntimeTurnOptions, type SetStreamingOptions } from './types.js';
 import type { RuntimeInputKind } from './runtime-cards.js';
 import type { ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, SessionRule } from './approval-types.js';
 import type { RuntimeInputAnswers, RuntimeInputChoice, RuntimeInputNativeMetadata, RuntimeInputQuestion, RuntimeCardNativeMetadata, RuntimeCardV1 } from './runtime-cards.js';
 import type { InboundDisposition } from './turn-protocol.js';
 import { type CanonVerbWireRequest, type CanonVerbWireResponse, type CommunicateInput, type CommunicateResult, type DiscoverAgentsInput, type DiscoverAgentsResult, type SendToInput } from '../backend-contracts/index.js';
-import type { WorkSessionRuntimeRegistration, WorkSessionRuntimeState, WorkSessionHeartbeatInput, WorkSessionRuntimeAuth, WorkSessionClaimInput, WorkSessionClaimResult, CompleteWorkSessionInput, WorkSessionRequest, ReleaseWorkSessionBindingInput, WorkSessionReportInput } from '../backend-contracts/index.js';
 import { type EndpointOperation } from '../endpoint/index.js';
 import { type CanonClientEndpointOptions, type CanonEndpoint } from './endpoint-client.js';
-import { type CanonConversationArtifacts } from './artifacts.js';
 export interface ResumableMediaUploadSession {
     uploadId: string;
     /** Private bearer capability returned by Cloud Storage. Do not persist or log it. */
@@ -28,18 +25,6 @@ export interface ResumableMediaUploadResult {
  * operator registration remain outside the conversation protocol.
  */
 export declare class CanonClient {
-    private workSessionRequest;
-    registerWorkSessionRuntime(input: WorkSessionRuntimeRegistration): Promise<WorkSessionRuntimeState>;
-    heartbeatWorkSessionRuntime(input: WorkSessionHeartbeatInput): Promise<WorkSessionRuntimeState>;
-    releaseWorkSessionRuntime(input: WorkSessionRuntimeAuth): Promise<{
-        released: boolean;
-    }>;
-    claimWorkSessionRequest(input: WorkSessionClaimInput): Promise<WorkSessionClaimResult>;
-    completeWorkSessionRequest(input: CompleteWorkSessionInput): Promise<WorkSessionRequest>;
-    releaseWorkSessionBinding(input: ReleaseWorkSessionBindingInput): Promise<WorkSessionRuntimeState>;
-    reportWorkSessionDetails(input: WorkSessionReportInput): Promise<{
-        reportedAt: number;
-    }>;
     private baseUrl;
     private apiKey;
     private endpointOptions;
@@ -49,16 +34,6 @@ export declare class CanonClient {
     constructor(apiKey: string, baseUrl?: string, options?: CanonClientEndpointOptions);
     /** All durable communication shares this installation's engine and journal. */
     getEndpoint(): Promise<CanonEndpoint>;
-    /** Last-seen snapshots and participant names for shared work, per conversation. */
-    private readonly artifactMemory;
-    /**
-     * Shared work bound to one conversation. Cheap to create: replay state lives
-     * in the endpoint and "last seen" snapshots on this client, so every room
-     * object for the same conversation shares them.
-     */
-    artifacts(conversationId: string): CanonConversationArtifacts;
-    /** Seed participant names used by shared-work views (for example an inbound message's sender). */
-    rememberParticipantNames(conversationId: string, names: Record<string, string | null | undefined>): void;
     close(): Promise<void>;
     getFileMediaPipeline(fetchImpl?: typeof fetch): Promise<import("../endpoint/index.js").EndpointMediaPipeline<string>>;
     waitForOperation<T>(operationId: string, options?: {
@@ -69,17 +44,8 @@ export declare class CanonClient {
     private endpointQuery;
     private endpointPublish;
     private authHeaders;
-    getAuthToken(): Promise<{
-        token: string;
-        expiresAt: string;
-        agentId: string;
-    }>;
     getAgentMe(): Promise<AgentContext>;
     discoverAgents(input?: DiscoverAgentsInput): Promise<DiscoverAgentsResult>;
-    updateAgentProfile(options: UpdateAgentProfileOptions): Promise<void>;
-    rotateAgentKey(): Promise<{
-        apiKey: string;
-    }>;
     /**
      * List conversations. Called with no options this is the historical request —
      * no query string, every conversation the agent belongs to, most recent
@@ -98,8 +64,6 @@ export declare class CanonClient {
     private fetchConversationsPage;
     /** Targeted membership read; session hosts must not poll the entire account. */
     getConversation(conversationId: string): Promise<CanonConversation | null>;
-    /** Stream and snapshot producers share the engine's monotonic roster merge. */
-    rememberConversation(conversation: CanonConversation): Promise<CanonConversation>;
     getMessages(conversationId: string, limit?: number, before?: string): Promise<CanonMessage[]>;
     getMessagesPage(conversationId: string, limit?: number, before?: string): Promise<CanonMessagesPage>;
     /** Read one explicitly referenced message without extending ordinary history. */
@@ -153,14 +117,6 @@ export declare class CanonClient {
         messageId: string;
         conversationId: string;
     }>;
-    /** Inspect the original durable publication before renewing an expired attachment.
-     * Pending or uncertain operations must be reconciled before any replacement.
-     * A replacement operation ID belongs in the caller's durable product journal;
-     * retain the same messageId and use it only after a definitive no-effect rejection.
-     */
-    getProactiveMessageOperation(conversationId: string, messageId: string, delivery?: {
-        operationId?: string;
-    }): Promise<EndpointOperation | undefined>;
     /** Reconcile an existing publication without rebuilding or resubmitting its body. */
     waitForProactiveMessage(operationId: string, options?: {
         signal?: AbortSignal;
@@ -190,6 +146,7 @@ export declare class CanonClient {
      */
     communicate(input: CommunicateInput): Promise<CommunicateResult>;
     private executeCommunication;
+    private startWithheld;
     /** Create a group. Direct conversations must go through `communicate`. */
     createGroup(options: CreateGroupOptions): Promise<CreateGroupResult>;
     createMemoStream(options: CreateMemoStreamOptions & {
@@ -225,8 +182,6 @@ export declare class CanonClient {
     createResumableMediaUpload(conversationId: string, sizeBytes: number, mimeType: string, fileName?: string): Promise<ResumableMediaUploadSession>;
     /** Promote validated pending bytes into a canonical Canon attachment. */
     finalizeResumableMediaUpload(uploadId: string): Promise<ResumableMediaUploadResult>;
-    getFeaturedGifs(options?: Omit<CanonGifSearchOptions, 'query'>): Promise<CanonGifSearchResponse>;
-    searchGifs(query: string, options?: Omit<CanonGifSearchOptions, 'query'>): Promise<CanonGifSearchResponse>;
     updateTopic(conversationId: string, topic: string): Promise<void>;
     deleteMessage(conversationId: string, messageId: string): Promise<void>;
     updateMessageDisposition(conversationId: string, messageId: string, inboundDisposition: InboundDisposition): Promise<void>;
@@ -244,15 +199,6 @@ export declare class CanonClient {
     /** Acknowledge exactly the signal observed before the native handler ran. */
     acknowledgeRuntimeSignal(conversationId: string, signalId: string): Promise<Record<string, unknown>>;
     consumeRuntimeSignal(conversationId: string): Promise<Record<string, unknown>>;
-    listRuntimePrimitives(conversationId: string): Promise<{
-        requests: Record<string, {
-            value: unknown;
-            revision: string;
-        }>;
-    }>;
-    consumeRuntimePrimitive(conversationId: string, requestId: string, expectedRevision: string): Promise<{
-        status: 'consumed' | 'missing' | 'mismatch';
-    }>;
     /** Runtime adapters can inspect only their own projection in an admitted room. */
     getRuntimeProjection(family: 'agent-runtime' | 'agent-session' | 'turn-state' | 'runtime-info' | 'runtime-activity' | 'streaming', conversationId?: string): Promise<unknown>;
     publishRuntimeSession(conversationId: string, mode: 'patch' | 'clear', state?: Record<string, unknown>): Promise<void>;

package/dist/internal/core/constants.d.ts

@@ -1,4 +1 @@
 export declare const DEFAULT_BASE_URL: string;
-export declare const DEFAULT_STREAM_URL: string;
-export declare const DEFAULT_RTDB_URL: string;
-export declare const FIREBASE_WEB_API_KEY: string;

package/dist/internal/core/endpoint-client.d.ts

@@ -1,5 +1,6 @@
 import { createEndpoint, type EndpointMediaBytes, type EndpointMediaPipeline, type MlsDevProtectedPreparer, type MlsDevProtectedKeyPackagePreparer, type MlsDevProtectedGroupPreparer } from '../endpoint/index.js';
 import type { MlsDevClientConfiguration } from '../endpoint/mls-crypto.js';
+import type { CanonClientIdentity } from '../backend-contracts/index.js';
 export type CanonEndpoint = ReturnType<typeof createEndpoint>;
 /** Operator-owned custody. Keep the same object for every shared endpoint lease. */
 export interface CanonMlsDevCustody {
@@ -12,7 +13,7 @@ export interface CanonMlsDevOptions {
     custody: CanonMlsDevCustody;
 }
 export interface CanonClientEndpointOptions {
-    /** Explicit synthetic Dev opt-in; enrollment remains an operator action. */
+    /** Explicit synthetic opt-in, bound to its configuration's environment; enrollment remains an operator action. */
     mlsDev?: CanonMlsDevOptions;
     /** Inject an operator-controlled store/engine for replicated or ephemeral hosts. */
     endpoint?: CanonEndpoint;
@@ -21,6 +22,11 @@ export interface CanonClientEndpointOptions {
     streamUrl?: string;
     /** Persistent volume for the engine journal; never use a container temporary directory. */
     stateDirectory?: string;
+    /**
+     * The engine's installation, for a host whose installation is assigned (the class-C relay's reserved one). A store
+     * already opened under another installation refuses to start; without it a new store picks a random installation.
+     */
+    installationId?: string;
     mediaDirectory?: string;
     /** Operator inspection/import does not automatically publish queued operations. */
     autoDrain?: boolean;
@@ -28,6 +34,13 @@ export interface CanonClientEndpointOptions {
     mediaBytes?: EndpointMediaBytes<string>;
     /** Test seam for the client's out-of-protocol HTTP (identity, profile); production leaves it unset. */
     fetch?: typeof fetch;
+    /**
+     * Names this client to Canon's client floor (`X-Canon-Client`, mls-cutover-operator.md §2 15b). The runner, the Hermes
+     * worker and the CLIs pass theirs; a client that names none is refused once a floor exists.
+     */
+    client?: CanonClientIdentity;
+    /** Canon refused this client as below its floor, on any request or stream (`426 CLIENT_UPDATE_REQUIRED`). */
+    onClientUpdateRequired?(error: Error): void;
 }
 export declare function acquireFileMediaPipeline(endpoint: CanonEndpoint, options: CanonClientEndpointOptions, fetchImpl?: typeof fetch): Promise<EndpointMediaPipeline<string>>;
 /** One protocol owner per account, environment and durable profile in this process. */

package/dist/internal/core/execution-environment-mode.d.ts

@@ -4,5 +4,3 @@
  * Node hosts and browser/Expo clients can import these primitives.
  */
 export type ExecutionEnvironmentMode = 'worktree' | 'locked';
-export declare const EXECUTION_ENVIRONMENT_MODES: readonly ExecutionEnvironmentMode[];
-export declare function isExecutionEnvironmentMode(value: unknown): value is ExecutionEnvironmentMode;

package/dist/internal/core/gifs.d.ts

@@ -17,12 +17,6 @@ export interface CanonGifSearchResponse {
     results: CanonGifResult[];
     nextCursor: string | null;
 }
-export interface CanonGifSearchOptions {
-    query?: string;
-    limit?: number;
-    cursor?: string | null;
-    locale?: string | null;
-}
 export interface CanonGifMetadata {
     provider: GifProvider;
     id: string;