@canonmsg/agent-sdk 13.1.0 → 13.2.0

package/dist/cli.js

@@ -25,7 +25,7 @@ import {
   runMlsDevSetup,
   startRelayChannel,
   writeRelayCredential
-} from "./chunks/chunk-IEKVS7AN.js";
+} from "./chunks/chunk-6FD6KFQN.js";
 import {
   assertPrivateHome,
   runnerLockName
@@ -40,7 +40,7 @@ import {
   resolveCanonRuntimeConnection,
   runCli,
   verifyCanonRuntimeConnection
-} from "./chunks/chunk-ZPBOGOAD.js";
+} from "./chunks/chunk-5YKGDUJX.js";
 import "./chunks/chunk-YJUPKU47.js";
 import "./chunks/chunk-YHDDOADK.js";
 import {

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   runMlsDevSetup,
   runtimeDescriptor,
   startRelayChannel
-} from "./chunks/chunk-IEKVS7AN.js";
+} from "./chunks/chunk-6FD6KFQN.js";
 import "./chunks/chunk-DTAWEQCM.js";
 import {
   CanonApiError,
@@ -52,7 +52,7 @@ import {
   toAnthropicImageBlock,
   toAnthropicImageBlocksWithinBudget,
   uploadMediaFile
-} from "./chunks/chunk-ZPBOGOAD.js";
+} from "./chunks/chunk-5YKGDUJX.js";
 import "./chunks/chunk-YJUPKU47.js";
 import "./chunks/chunk-YHDDOADK.js";
 import "./chunks/chunk-5WPAB5MB.js";

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

@@ -1,11 +1,6 @@
 import type { AgentWakeConfiguration } from '../backend-contracts/index.js';
-import { type CanonMessage, type CanonConversation, type CanonUnifiedDiff, type CanonMessagesPage, type AgentContext, type MediaAttachment, type SendMessageOptions, 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 CanonMessage, type CanonConversation, type CanonMessagesPage, type AgentContext, type MediaAttachment, type SendMessageOptions, type RegistrationStatus, type AgentOriginDeclaration, type SetRuntimeTurnOptions } from './types.js';
 import { type CanonVerbWireRequest, type CanonVerbWireResponse, type CommunicateInput, type CommunicateResult, type DiscoverAgentsInput, type DiscoverAgentsResult } from '../backend-contracts/index.js';
-import { type EndpointOperation } from '../endpoint/index.js';
 import { type CanonClientEndpointOptions, type CanonEndpoint } from './endpoint-client.js';
 export interface ResumableMediaUploadResult {
     uploadId: string;
@@ -53,28 +48,6 @@ export declare class CanonClient {
     }): Promise<{
         messageId: string;
     }>;
-    /** Inspect a trusted reply's durable delivery without rebuilding its body. */
-    getMessageOperation(conversationId: string, messageId: string, delivery?: {
-        operationId?: string;
-    }): Promise<EndpointOperation | undefined>;
-    /** Core's chunker records all ordered message intents before publishing any part. */
-    prepareMessageGroup(conversationId: string, messageId: string, parts: Array<{
-        text: string;
-        options: SendMessageOptions;
-    }>, delivery?: {
-        operationId?: string;
-        signal?: AbortSignal;
-        replacesOperationId?: string;
-    }): Promise<{
-        id: string;
-        sendPart(index: number, options?: {
-            signal?: AbortSignal;
-            timeoutMs?: number;
-        }): Promise<{
-            messageId: string;
-        }>;
-    }>;
-    cancelMessageGroup(id: string): Promise<void>;
     /**
      * Execute a canonical verb over the wire contract (canon.verb-wire.v1).
      * Bindings build the request with projectVerbIntentToWire; the endpoint
@@ -99,13 +72,10 @@ export declare class CanonClient {
     private startWithheld;
     blockUser(userId: string): Promise<void>;
     deleteMessage(conversationId: string, messageId: string): Promise<void>;
-    updateMessageDisposition(conversationId: string, messageId: string, inboundDisposition: InboundDisposition): Promise<void>;
     markAsRead(conversationId: string): Promise<void>;
     react(conversationId: string, messageId: string, emoji: string): Promise<void>;
-    setStreaming(options: SetStreamingOptions): Promise<void>;
     clearStreaming(conversationId: string): Promise<void>;
     setRuntimeTurn(options: SetRuntimeTurnOptions): Promise<void>;
-    setTyping(conversationId: string, typing: boolean, status?: 'thinking' | 'typing'): Promise<void>;
     peekRuntimeSignal(conversationId: string): Promise<Record<string, unknown>>;
     /** Acknowledge exactly the signal observed before the native handler ran. */
     acknowledgeRuntimeSignal(conversationId: string, signalId: string): Promise<Record<string, unknown>>;
@@ -124,190 +94,6 @@ export declare class CanonClient {
         mode: 'clear';
     }): Promise<void>;
     patchRuntimeStreaming(conversationId: string, patch: Record<string, unknown>): Promise<void>;
-    createRuntimeInputRequest(options: {
-        conversationId: string;
-        inputId: string;
-        kind: RuntimeInputKind;
-        expiresAt: number;
-        title?: string;
-        prompt?: string;
-        choices?: RuntimeInputChoice[];
-        questions?: RuntimeInputQuestion[];
-        secretName?: string;
-        native?: RuntimeInputNativeMetadata;
-        sensitive?: boolean;
-        responseUserId?: string;
-        turnId?: string;
-    }): Promise<{
-        success: true;
-        inputId: string;
-        expiresAt: number;
-        messageId?: string;
-    }>;
-    consumeRuntimeInputResponse(options: {
-        conversationId: string;
-        inputId: string;
-        cancel?: boolean;
-    }): Promise<{
-        status: 'pending';
-        inputId: string;
-        expiresAt?: number;
-    } | {
-        status: 'submitted';
-        inputId: string;
-        kind: RuntimeInputKind;
-        value: string;
-        answers?: RuntimeInputAnswers;
-    } | {
-        status: 'cancelled';
-        inputId: string;
-        kind: RuntimeInputKind;
-    } | {
-        status: 'timeout';
-        inputId: string;
-        kind: RuntimeInputKind;
-    }>;
-    createRuntimeApprovalRequest(options: {
-        conversationId: string;
-        approvalId?: string;
-        toolName: string;
-        toolSummary: string;
-        expiresAt: number;
-        responseUserId?: string;
-        riskLevel?: 'normal' | 'destructive';
-        risk?: ApprovalRisk;
-        category?: ApprovalRequestCategory;
-        runtimeId?: string;
-        turnId?: string;
-        native?: ApprovalNativeRequestMetadata;
-        details?: ApprovalRequestDetail[];
-        /** File-change preview rendered inline on the approval card. Truncate via truncateUnifiedDiff before sending. */
-        diff?: CanonUnifiedDiff;
-        allowSessionRule?: boolean;
-    }): Promise<{
-        success: true;
-        approvalId: string;
-        expiresAt: number;
-        messageId?: string;
-        responseUserId: string;
-        allowSessionRule: boolean;
-    }>;
-    consumeRuntimeApprovalResponse(options: {
-        conversationId: string;
-        approvalId: string;
-        cancel?: boolean;
-    }): Promise<{
-        status: 'pending';
-        approvalId: string;
-        expiresAt?: number;
-    } | {
-        status: 'allow';
-        approvalId: string;
-        sessionRule?: SessionRule;
-        respondedBy?: string;
-    } | {
-        status: 'deny';
-        approvalId: string;
-        sessionRule?: SessionRule;
-        respondedBy?: string;
-    } | {
-        status: 'timeout';
-        approvalId: string;
-    }>;
-    createRuntimeCardRequest(options: {
-        conversationId: string;
-        card: RuntimeCardV1;
-        cardId?: string;
-        expiresAt?: number;
-        responseUserId?: string;
-        runtimeId?: string;
-        turnId?: string;
-        native?: RuntimeCardNativeMetadata;
-    }): Promise<{
-        success: true;
-        cardId: string;
-        messageId: string;
-        /** True when the card has actions and a response is pending; false for display cards. */
-        interactive: boolean;
-        /** Effective human responder selected by Canon. */
-        responseUserId?: string;
-        /** Present only for interactive cards. */
-        expiresAt?: number;
-    }>;
-    consumeRuntimeCardResponse(options: {
-        conversationId: string;
-        cardId: string;
-        cancel?: boolean;
-    }): Promise<{
-        status: 'pending';
-        cardId: string;
-        expiresAt?: number;
-    } | {
-        status: 'submitted';
-        cardId: string;
-        actionId?: string;
-        values?: Record<string, unknown>;
-        respondedBy?: string;
-    } | {
-        status: 'cancelled';
-        cardId: string;
-        respondedBy?: string;
-    } | {
-        status: 'timeout';
-        cardId: string;
-    }>;
-    /**
-     * Create a server-owned plan-approval interaction.
-     *
-     * Seeds the pending node + attention + runtime-card state and authors the
-     * `plan_approval` card message, mirroring the other `createRuntime*Request`
-     * spine methods. Hosts resolve it through `consumeRuntimePlanResponse()` so
-     * the canonical pending state, rather than a timeline receipt, is authoritative.
-     */
-    createRuntimePlanRequest(options: {
-        conversationId: string;
-        planId?: string;
-        title?: string;
-        summary?: string;
-        body?: string;
-        allowedPrompts?: ReadonlyArray<{
-            tool: string;
-            prompt: string;
-        }>;
-        responseUserId?: string;
-        turnId?: string;
-        expiresAt?: number;
-    }): Promise<{
-        success: true;
-        planId: string;
-        expiresAt: number;
-        messageId?: string;
-        interactive: boolean;
-    }>;
-    consumeRuntimePlanResponse(options: {
-        conversationId: string;
-        planId: string;
-        cancel?: boolean;
-    }): Promise<{
-        status: 'pending';
-        planId: string;
-        expiresAt?: number;
-    } | {
-        status: 'approve' | 'revise' | 'reject';
-        planId: string;
-        feedback?: string;
-        grantedPrompts?: Array<{
-            tool: string;
-            prompt: string;
-        }>;
-        receiptId?: string;
-    } | {
-        status: 'cancelled';
-        planId: string;
-    } | {
-        status: 'timeout';
-        planId: string;
-    }>;
     updateRuntimeStatus(options: {
         runtime: string;
         hostMode?: boolean;

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

@@ -57,4 +57,3 @@ export { CANON_VERB_NAMES, CANON_VERB_NAMESPACE, CANON_VERBS_SCHEMA_ID, CANON_VE
 export { DEFAULT_DISCOVER_AGENTS_LIMIT, MAX_DISCOVER_AGENTS_LIMIT, MAX_DISCOVER_AGENTS_QUERY_LENGTH, type CanonAgentDirectoryEntry, type DiscoverAgentsInput, type DiscoverAgentsResult, } from '../backend-contracts/index.js';
 export { parseDirectConversationSelection, readCommunicationRule, type CommunicateInput, type CommunicateResult, type CommunicationRule, type DirectConversationSelection, type StartDirectInput, type StartDirectResult, } from '../backend-contracts/index.js';
 export { canonMediaDownloadUrl, sanitizeDownloadFileName, buildMediaContentDisposition, getStoredFileExtension } from '../backend-contracts/index.js';
-export * from './completed-output-journal.js';

package/dist/internal/endpoint/completions.d.ts

@@ -0,0 +1,45 @@
+import { type EndpointStore, type EndpointStoreTransaction } from './store.js';
+/**
+ * A runtime's finished output, recorded before it is published: a turn's answer, or text a host sends with no turn. A
+ * host that dies between the answer and Canon's acceptance publishes exactly that output on restart and never runs the
+ * turn again. One record holds the answer, the inputs it answers and the audience it may reach, in the engine's own
+ * store, so recording it and settling its inputs once it is durable are each one transaction with the inbox.
+ */
+export interface EndpointCompletion<T = unknown> {
+    version: 1;
+    id: string;
+    conversationId: string;
+    /** The inbox inputs it answers. They settle with it (`finishCompletion`); an uncertain input that no completion names is an orphan. */
+    inputIds: string[];
+    /** The audience its publication may reach (an encrypted room's group head, roster and admissions), or null. */
+    fence: unknown;
+    /** What the runtime answered, as its host records it. */
+    output: T;
+    createdAt: string;
+}
+/** Completions in the engine's store. Every write checks the current installation, as content writes do. */
+export declare function createCompletions(input: {
+    store: EndpointStore;
+    ready(): Promise<unknown>;
+    assertOpen(): void;
+    assertCurrent(tx: EndpointStoreTransaction): Promise<void>;
+    /** Settles one inbox input inside the caller's transaction, as `setInboundState` does. */
+    settleInbound(tx: EndpointStoreTransaction, id: string, reason: string): Promise<void>;
+}): {
+    save(record: EndpointCompletion): Promise<void>;
+    get<T>(id: string): Promise<EndpointCompletion<T> | undefined>;
+    /** Oldest first. */
+    list<T>(): Promise<Array<EndpointCompletion<T>>>;
+    /** One record for another, in one step: a Stop's cut keeps only what was already queued. */
+    replace(previousId: string, next: EndpointCompletion): Promise<void>;
+    /**
+     * The output is durable or withdrawn: its record goes, and in the same step `settle`'s inputs settle. An input already
+     * settled, or no longer in the inbox, is left as it is.
+     */
+    finish(id: string, settle?: {
+        inputIds: readonly string[];
+        reason: string;
+    }): Promise<void>;
+    /** The input ids every completion names, read inside the caller's transaction. */
+    answered(tx: EndpointStoreTransaction): Promise<Set<string>>;
+};

package/dist/internal/endpoint/engine.d.ts

@@ -10,6 +10,7 @@ import { type EndpointRecoveryMigration, type EndpointMigrationReceipt } from '.
 import { type EndpointBackgroundMediaAdapter, type EndpointMediaBytes, type EndpointMediaPipeline } from './media.js';
 import { type EndpointOrdering } from './queue.js';
 import { type EndpointInboundHandoff, type EndpointInboundStartResult } from './handoff.js';
+import { type EndpointCompletion } from './completions.js';
 import { type ExternalInboundClaim } from './external-inbound.js';
 import type { EndpointExternalInboundClaimResult, EndpointExternalInboundOutcome } from '../backend-contracts/index.js';
 import { type MlsDevGroupClient } from './mls-dev-groups.js';
@@ -246,11 +247,25 @@ export interface Endpoint {
     }): Promise<boolean>;
     acceptInbound(options: EndpointInboundConsumerOptions): EndpointInboundConsumer;
     setInboundState(id: string, state: EndpointInboundState, reason?: string): Promise<void>;
+    /** `unanswered`: only inputs no completion names (`completions.ts`), read in the same transaction. */
     listInbound(options?: {
         states?: EndpointInboundState[];
         after?: string;
         limit?: number;
+        unanswered?: boolean;
     }): Promise<EndpointInboundRecord[]>;
+    /** A runtime's finished output, recorded before it is published (`completions.ts`). The same record again is a no-op. */
+    saveCompletion(record: EndpointCompletion): Promise<void>;
+    getCompletion<T = unknown>(id: string): Promise<EndpointCompletion<T> | undefined>;
+    /** Every recorded completion, oldest first. */
+    listCompletions<T = unknown>(): Promise<Array<EndpointCompletion<T>>>;
+    /** One completion for another, in one transaction. */
+    replaceCompletion(previousId: string, next: EndpointCompletion): Promise<void>;
+    /** The output is durable or withdrawn: the completion goes, and `settle`'s inputs settle, in one transaction. */
+    finishCompletion(id: string, settle?: {
+        inputIds: readonly string[];
+        reason: string;
+    }): Promise<void>;
     discardPending(): Promise<void>;
     logout(): Promise<void>;
     close(): Promise<void>;

package/dist/internal/endpoint/index.d.ts

@@ -1,4 +1,5 @@
 export * from './engine.js';
+export type { EndpointCompletion } from './completions.js';
 export * from './store.js';
 export * from './transport.js';
 export * from './observe-query.js';

package/dist/media.js

@@ -18,7 +18,7 @@ import {
   toAnthropicImageBlock,
   toAnthropicImageBlocksWithinBudget,
   uploadMediaFile
-} from "./chunks/chunk-ZPBOGOAD.js";
+} from "./chunks/chunk-5YKGDUJX.js";
 import "./chunks/chunk-YJUPKU47.js";
 import "./chunks/chunk-YHDDOADK.js";
 import "./chunks/chunk-5WPAB5MB.js";

package/dist/runner/errands.d.ts

@@ -95,8 +95,8 @@ export declare function awaitErrand(directory: string, command: Pick<ErrandComma
     accepted: boolean;
 }>;
 export interface ErrandHandler {
-    /** The command was taken already (its record or its journaled output exists): its file is only removed. */
-    taken(id: string): boolean;
+    /** The command was taken already (its record or its saved output exists): its file is only removed. */
+    taken(id: string): boolean | Promise<boolean>;
     /**
      * The command, or why its file is refused. True once its effect (or refusal) is journaled, so the file may go; false
      * leaves it for the next scan. A throw is logged once per command and reason, and also leaves it.

package/dist/runner/runner.d.ts

@@ -102,7 +102,12 @@ export interface Runner {
     start(): Promise<void>;
     /** Stops intake, releases unsubmitted input, lets running turns finish within the shutdown grace. */
     stop(): Promise<void>;
-    /** A proactive send outside any turn (cron): the `communicate` tool's handler, under the runner's identity. */
+    /**
+     * A proactive send outside any turn (cron), under the runner's identity, with the `communicate` tool's input. Text to a
+     * conversation is encrypted for the members it has now, journaled first and sent once, even across a restart; a new
+     * conversation is founded encrypted by this device. `messageId` makes a retry the same message or start. Other actions
+     * go to Canon as they are.
+     */
     communicate(input: CommunicateInput): Promise<CommunicateResult>;
     /** What the runner has in hand now, for a host's idle policy (agent-wake.md). Only between start and stop. */
     activity(): Promise<RunnerActivity>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/agent-sdk",
-  "version": "13.1.0",
+  "version": "13.2.0",
   "description": "Canon Agent SDK — build AI agents that participate in Canon conversations",
   "type": "module",
   "main": "dist/index.js",

package/dist/internal/core/completed-output-journal.d.ts

@@ -1,34 +0,0 @@
-/**
- * A runtime's finished turn output, saved before it is published so a host that
- * dies between the native result and Canon delivery replays exactly that
- * output on restart instead of losing it, and never runs the turn again.
- */
-export interface CompletedOutputRecordBase {
-    version: 1;
-    turnId: string;
-    conversationId: string;
-    createdAt: string;
-    /** Who could read the conversation when the output was produced. */
-    audience: {
-        memberIds: string[];
-        membershipRevision?: number;
-    } | null;
-}
-export interface CompletedOutputJournal<T extends CompletedOutputRecordBase> {
-    /** Durably save a record; saving the identical record again is a no-op, a different one is refused. */
-    save(record: T): void;
-    /** Every saved record, oldest first, after recovering writes a crash interrupted. */
-    list(): T[];
-    remove(turnId: string): void;
-}
-/**
- * Atomic, fsynced, one file per turn under a folder keyed by `scope` (runtime,
- * environment, principal, ownership generation, installation), so a transferred
- * agent or another installation never sees these plaintext records.
- */
-export declare function createCompletedOutputJournal<T extends CompletedOutputRecordBase>(directory: string, scope: unknown, options: {
-    /** Names the runtime in errors, e.g. `Codex`. */
-    label: string;
-    /** Runtime-specific shape check beyond the base fields; false is an invalid record. */
-    validate?: (record: T) => boolean;
-}): CompletedOutputJournal<T>;