@skrr-ai/cli 0.1.8

package/dist/commands/agent/call/request.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const prompt_1 = require("../../../lib/prompt");
+const voice_call_intent_1 = require("../../../lib/voice-call-intent");
+const MAX_REASON_CHARS = 500;
+const MAX_IDEMPOTENCY_KEY_CHARS = 240;
+const DEFAULT_EXPIRES_IN_SECONDS = 120;
+class AgentCallRequest extends base_command_1.BaseCommand {
+    static description = 'Request an app voice call with the current Agent session owner; the owner must accept before LiveKit starts';
+    static examples = [
+        '<%= config.bin %> agent call request --reason "A release decision needs you" --json',
+        '<%= config.bin %> agent call request --from-json - --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Emit the stable machine response on stdout' }),
+        reason: core_1.Flags.string({
+            description: `Why a call is needed (1-${MAX_REASON_CHARS} characters)`,
+        }),
+        conversation: core_1.Flags.string({
+            description: 'Optional existing conversation ID to continue in the call',
+        }),
+        'expires-in': core_1.Flags.integer({
+            description: 'Invite lifetime in seconds (30-300; default 120)',
+        }),
+        'idempotency-key': core_1.Flags.string({
+            description: 'Stable retry key; a daemon-session default is derived when omitted',
+        }),
+        'from-json': core_1.Flags.string({
+            description: 'Read {reason, conversationId?, expiresInSeconds?, idempotencyKey?} from a file or "-"',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AgentCallRequest);
+        const context = this.sessionContext();
+        let json = {};
+        try {
+            json = await (0, prompt_1.readJsonBody)(flags['from-json']);
+        }
+        catch (error) {
+            this.failWithCliError({
+                message: error instanceof Error ? error.message : String(error),
+                code: 'INVALID_JSON_INPUT',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        for (const forbidden of ['agentId', 'sessionId', 'ownerUserId', 'targetUserId']) {
+            if (json[forbidden] !== undefined) {
+                this.failWithCliError({
+                    message: `--from-json must not set "${forbidden}"; call identity and target come from the Agent session.`,
+                    code: 'VOICE_CALL_IDENTITY_OVERRIDE_FORBIDDEN',
+                    exit: 1,
+                    retryable: false,
+                });
+            }
+        }
+        let reason;
+        let conversationId;
+        let expiresInSeconds;
+        let suppliedKey;
+        try {
+            const input = (0, prompt_1.mergeDefined)(json, {
+                reason: flags.reason,
+                conversationId: flags.conversation,
+                expiresInSeconds: flags['expires-in'],
+                idempotencyKey: flags['idempotency-key'],
+            });
+            reason = requiredText(input.reason, 'reason', MAX_REASON_CHARS);
+            conversationId = optionalText(input.conversationId ?? input.conversation_id, 'conversationId', 240);
+            expiresInSeconds = requiredInteger(input.expiresInSeconds ?? input.expires_in_seconds ?? DEFAULT_EXPIRES_IN_SECONDS, 'expiresInSeconds');
+            suppliedKey = optionalText(input.idempotencyKey ?? input.idempotency_key ?? input['idempotency-key'], 'idempotencyKey', MAX_IDEMPOTENCY_KEY_CHARS);
+        }
+        catch (error) {
+            this.failWithCliError({
+                message: error instanceof Error ? error.message : String(error),
+                code: 'INVALID_VOICE_CALL_REQUEST',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (expiresInSeconds < 30 || expiresInSeconds > 300) {
+            this.failWithCliError({
+                message: 'expiresInSeconds must be between 30 and 300.',
+                code: 'VOICE_CALL_EXPIRY_INVALID',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const idempotencyKey = suppliedKey ||
+            (0, voice_call_intent_1.generatedVoiceCallIdempotencyKey)({
+                context,
+                reason: reason,
+                conversationId,
+                expiresInSeconds: expiresInSeconds,
+            });
+        try {
+            const result = await (0, voice_call_intent_1.requestVoiceCall)({
+                context,
+                reason: reason,
+                conversationId,
+                expiresInSeconds: expiresInSeconds,
+                idempotencyKey,
+            });
+            const envelope = {
+                object: 'sky.agent_voice_call',
+                ok: result.ok !== false,
+                command: 'agent call request',
+                agent: { id: context.agentId },
+                idempotencyKey,
+                call: result.call,
+                ...(result.duplicate ? { duplicate: true } : {}),
+                ...(result.coalesced ? { coalesced: true } : {}),
+            };
+            if (flags.json) {
+                this.log(JSON.stringify(envelope, null, 2));
+            }
+            else if (result.coalesced) {
+                this.log(`Existing call invite ${result.call.id} is still ${result.call.status}.`);
+            }
+            else if (result.duplicate) {
+                this.log(`Call invite ${result.call.id} is unchanged (${result.call.status}).`);
+            }
+            else {
+                this.log(`Call invite ${result.call.id} sent; expires ${result.call.expiresAt}.`);
+            }
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+    sessionContext() {
+        try {
+            return (0, voice_call_intent_1.readVoiceCallSessionContext)();
+        }
+        catch (error) {
+            const err = error;
+            this.failWithCliError({
+                message: err.message,
+                code: err.code || 'VOICE_CALL_SESSION_REQUIRED',
+                exit: 2,
+                retryable: false,
+            });
+        }
+    }
+}
+exports.default = AgentCallRequest;
+function requiredText(value, name, max) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error(`${name} is required.`);
+    }
+    const normalized = value.trim();
+    if (normalized.length > max)
+        throw new Error(`${name} must be at most ${max} characters.`);
+    return normalized;
+}
+function optionalText(value, name, max) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${name} must be a non-empty string.`);
+    const normalized = value.trim();
+    if (normalized.length > max)
+        throw new Error(`${name} must be at most ${max} characters.`);
+    return normalized;
+}
+function requiredInteger(value, name) {
+    const number = typeof value === 'number' ? value : Number(value);
+    if (!Number.isInteger(number))
+        throw new Error(`${name} must be an integer.`);
+    return number;
+}

package/dist/commands/agent/call/show.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentCallShow extends BaseCommand {
+    static description: string;
+    static args: {
+        callId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agent/call/show.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const voice_call_intent_1 = require("../../../lib/voice-call-intent");
+class AgentCallShow extends base_command_1.BaseCommand {
+    static description = 'Show the status of an app voice-call invite created by this Agent session';
+    static args = {
+        callId: core_1.Args.string({ description: 'Voice call invite ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Emit the stable machine response on stdout' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AgentCallShow);
+        let context;
+        try {
+            context = (0, voice_call_intent_1.readVoiceCallSessionContext)();
+        }
+        catch (error) {
+            const err = error;
+            this.failWithCliError({
+                message: err.message,
+                code: err.code || 'VOICE_CALL_SESSION_REQUIRED',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        try {
+            const result = await (0, voice_call_intent_1.showVoiceCall)({ context, callId: args.callId });
+            const envelope = {
+                object: 'sky.agent_voice_call',
+                ok: result.ok !== false,
+                command: 'agent call show',
+                agent: { id: context.agentId },
+                call: result.call,
+            };
+            if (flags.json)
+                this.log(JSON.stringify(envelope, null, 2));
+            else
+                this.log(`Call invite ${result.call.id}: ${result.call.status}.`);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = AgentCallShow;

package/dist/commands/agent/message/context.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Show durable communication observations before an interactive local agent
+ * decides whether to contact the user. This command is intentionally advisory:
+ * it never returns a schedule or tells the model that it must send a message.
+ */
+export default class AgentMessageContext extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agent: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        run: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agent/message/context.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+const api_fetch_1 = require("../../../lib/api-fetch");
+const message_intent_1 = require("../../../lib/message-intent");
+/**
+ * Show durable communication observations before an interactive local agent
+ * decides whether to contact the user. This command is intentionally advisory:
+ * it never returns a schedule or tells the model that it must send a message.
+ */
+class AgentMessageContext extends base_command_1.BaseCommand {
+    static description = 'Show recent Agent Updates and user-engagement observations for adaptive communication judgment';
+    static examples = [
+        '<%= config.bin %> agent message context --agent <agent-id>',
+        '<%= config.bin %> agent message context --agent <agent-id> --task <task-id>',
+    ];
+    static args = {
+        agent: core_1.Args.string({ description: 'Agent ID', required: false, ignoreStdin: true }),
+    };
+    static flags = {
+        agent: core_1.Flags.string({ description: 'Agent ID' }),
+        task: core_1.Flags.string({ description: 'Optional task context to narrow recent updates' }),
+        run: core_1.Flags.string({ description: 'Optional run context to narrow recent updates' }),
+        // No `--json` flag: these observations exist to be parsed, so JSON is the
+        // only output. A flag that cannot be turned off is a lie in `--help`.
+    };
+    async run() {
+        const { args, flags } = await this.parse(AgentMessageContext);
+        const sessionContext = (0, message_intent_1.resolveMessageCommandSessionContext)({
+            requireHumanAuth: () => this.requireAuth(),
+        });
+        let agentId;
+        try {
+            const explicitAgentId = (0, agent_resolver_1.mergeExplicitAgentInputs)([
+                { label: 'agent argument', value: args.agent },
+                { label: '--agent', value: flags.agent },
+            ]);
+            agentId = sessionContext
+                ? (0, agent_resolver_1.resolveSessionAgentIdentity)(explicitAgentId).id
+                : (await (0, agent_resolver_1.resolveAgentIdentity)(explicitAgentId)).id;
+        }
+        catch (error) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(error);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: failure.suggestion ? { suggestion: failure.suggestion } : undefined,
+            });
+        }
+        try {
+            if (sessionContext?.sessionId) {
+                const params = new URLSearchParams();
+                if (flags.task)
+                    params.set('taskId', flags.task);
+                const query = params.size ? `?${params.toString()}` : '';
+                const result = await (0, api_fetch_1.apiFetch)(`/api/agentic/sessions/${encodeURIComponent(sessionContext.sessionId)}/message-context${query}`, { credential: (0, message_intent_1.sessionCredential)(sessionContext.token) });
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            // Through dataService, not a hand-built path: one route builder and one
+            // response type, shared with every other client. A second copy of the URL
+            // here is how the two drift.
+            const result = await data_provider_1.dataService.getAgentAdaptiveCommunicationContext(agentId, {
+                taskId: flags.task,
+                runId: flags.run,
+            });
+            this.log(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = AgentMessageContext;

package/dist/commands/agent/message/send.d.ts

@@ -0,0 +1,232 @@
+import { type EntityEmbed } from '@skrr-ai/data-provider';
+import { BaseCommand } from '../../../base-command';
+import { type ResolvedAgentIdentity } from '../../../lib/agent-resolver';
+import { type CanonicalMessageDestination, type CanonicalMessageIntentRequest, type CanonicalMessageIntentResponse, type CommunicationPresentation } from '../../../lib/message-intent';
+import { type WireEmbedRejection } from '../../../lib/entity-embeds';
+/**
+ * A reading-comfort prompt, not a protocol limit. The Gateway deliberately
+ * permits much larger payloads; the sender remains responsible for choosing
+ * meaningful conversational boundaries.
+ */
+export declare const OWNER_DM_SEGMENTATION_SOFT_LIMIT = 320;
+declare const PROTOCOL_VERSION = 1;
+export type PrincipalKind = 'session' | 'human';
+export type AgentMessageSendPayload = {
+    agentId?: string;
+    destination: CanonicalMessageDestination;
+    content: {
+        text: string;
+    };
+    idempotencyKey?: string;
+};
+export type CanonicalIntentEnvelope = {
+    ok: boolean;
+    protocolVersion: typeof PROTOCOL_VERSION;
+    command: 'agent message send';
+    server: string | null;
+    principalKind: PrincipalKind;
+    principalSource: string;
+    transport: 'gateway' | 'legacy_dm' | 'legacy_slack';
+    agent: {
+        id: string;
+        source: ResolvedAgentIdentity['source'];
+    };
+    destination: CanonicalMessageDestination;
+    content: {
+        text: string;
+    };
+    idempotencyKey: string;
+    /** Requested Agent Chat Thread root (the server remains authoritative). */
+    threadRootMessageId?: string;
+    /** Sender-declared semantics echoed for auditability; not a delivery promise. */
+    presentation?: CommunicationPresentation;
+    /** Legacy app-DM reach ceiling echoed when explicitly supplied. */
+    notificationPolicy?: 'normal' | 'silent';
+    /**
+     * Entities that were attached, and any the server refused.
+     *
+     * Rejections reach the AUTHOR only — they are the response to this request.
+     * A reader never learns that an embed was dropped, because "something was
+     * removed here" is itself a fact about an entity they cannot see.
+     */
+    embeds?: EntityEmbed[];
+    embedRejections?: WireEmbedRejection[];
+    intent: {
+        id: string | null;
+        status: NonNullable<CanonicalMessageIntentResponse['status']> | 'delivered' | 'submitted';
+        reason?: string;
+        retryAfter?: string;
+        retryable?: boolean;
+        initiativeId?: string;
+        /** The owner replied after this update began — withhold the tail. */
+        ownerInterjected?: boolean;
+    };
+};
+/**
+ * Canonical CLI entry for agent-authored messages.
+ *
+ * The command's principal kind is derived exclusively from the caller's
+ * credential — a session credential (`OVERSKY_SESSION_TOKEN`) selects the
+ * autonomous session Gateway path; every other resolved credential is a
+ * human. There is deliberately no flag that can force one path over the
+ * other; a `principalKind` field in the JSON payload is rejected so that
+ * a compromised producer cannot elevate itself into a session principal.
+ */
+export default class AgentMessageSend extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agent: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        text: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        part: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'message-lint': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        channel: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'thread-ts': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'thread-root': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'idempotency-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        kind: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        phase: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        importance: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        attention: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'requires-response': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'notification-policy': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'attach-task-card': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        goal: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        embed: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * Set the process exit code from the delivery outcome, AFTER the envelope has
+     * been written. The envelope is the diagnostic and must reach stdout whether
+     * or not the send succeeded; the exit code is the signal a script branches on.
+     *
+     * No-ops on success so the normal path still returns cleanly.
+     */
+    private exitForDelivery;
+    private readPayload;
+    private submitAsSession;
+    private submitAsHuman;
+}
+export type NormalizedIntentPayload = {
+    destination: CanonicalMessageDestination;
+    content: {
+        text: string;
+    };
+    idempotencyKey?: string;
+    /** Only present when the caller declared a kind or presentation object. */
+    presentation?: CommunicationPresentation;
+    notificationPolicy?: 'normal' | 'silent';
+    threadRootMessageId?: string;
+    context?: {
+        taskId?: string;
+        spaceId?: string;
+        goalId?: string;
+    };
+};
+/**
+ * Keep segmentation a sender decision: this advisory must never rewrite,
+ * reject, or automatically split the text. It only covers private owner DMs,
+ * where a chat-like reading cadence is normally expected.
+ */
+export declare function messageSegmentationAdvisory({ destination, text, followingParts, }: {
+    destination: CanonicalMessageDestination;
+    text: string;
+    followingParts: string[];
+}): string | undefined;
+/**
+ * Preserve the caller's semantic boundary while allowing them to send a few
+ * naturally separate short messages. A sequence is never automatic: the model
+ * chooses its boundaries, and retries remain safe because every part is derived
+ * from one explicit semantic idempotency key.
+ */
+export declare function buildSequencedRequests(request: CanonicalMessageIntentRequest, followingParts: string[], hasExplicitIdempotencyKey: boolean): CanonicalMessageIntentRequest[];
+/**
+ * Exit codes for a submitted-but-undelivered message.
+ *
+ * The command used to exit 0 whenever the transport ACCEPTED the request, even
+ * when the enclosed intent reported `status: "failed"`. The exit code is the
+ * only failure signal a shell script or a non-JSON-parsing agent has, so
+ * `sky ... || handle_failure` never fired and callers reported "sent" for
+ * messages that were never delivered.
+ *
+ * Two codes rather than one because the correct response differs: a retryable
+ * failure is worth re-attempting, a terminal one can only be fixed by changing
+ * the request. CLI-level rejections keep their existing 1 / 2.
+ */
+export declare const EXIT_DELIVERY_RETRYABLE = 3;
+export declare const EXIT_DELIVERY_FAILED = 4;
+/**
+ * Decide the process exit code from the envelopes actually produced.
+ *
+ * @returns 0 when every part is delivered or safely in flight; otherwise the
+ *   exit code for the FIRST failing part, since that is the one that halted the
+ *   sequence and the one whose reason explains the outcome.
+ */
+export declare function deliveryExitCode(envelopes: readonly CanonicalIntentEnvelope[]): number;
+export type SequenceHalt = {
+    /** Parts actually submitted, including the one that halted the sequence. */
+    sentParts: number;
+    /** Parts the caller asked for but that were deliberately never submitted. */
+    unsentParts: number;
+    status: CanonicalIntentEnvelope['intent']['status'];
+    reason?: string;
+};
+/**
+ * Decide whether a sequence stops after this part. Returns `undefined` when the
+ * sequence may continue — including for the final part, where there is nothing
+ * left to withhold and reporting a halt would be noise.
+ */
+export declare function sequenceHalt({ envelope, sentCount, totalParts, }: {
+    envelope: CanonicalIntentEnvelope;
+    sentCount: number;
+    totalParts: number;
+}): SequenceHalt | undefined;
+/**
+ * A caller MUST NOT be able to move themselves between principal kinds by
+ * shoving `principalKind` (or the related principal metadata) into the JSON
+ * payload. The credential resolves the kind; the payload is just data.
+ */
+export declare function rejectPrincipalOverrides(jsonBody: Record<string, unknown>, reporter: {
+    failWithCliError: (opts: {
+        message: string;
+        code: string;
+        exit: number;
+        retryable: boolean;
+    }) => never;
+}): void;
+export declare function normalizeIntentPayload({ agentId, jsonBody, merged, }: {
+    agentId: string;
+    jsonBody: Record<string, unknown>;
+    merged: Record<string, unknown>;
+}): NormalizedIntentPayload;
+export declare function generateIdempotencyKey(agentId: string, payload: Pick<NormalizedIntentPayload, 'destination' | 'content' | 'presentation' | 'context' | 'threadRootMessageId'>): string;
+export declare function buildEnvelope(input: {
+    ok: boolean;
+    principalKind: PrincipalKind;
+    principalSource: string;
+    transport: CanonicalIntentEnvelope['transport'];
+    server: string | null;
+    agent: ResolvedAgentIdentity;
+    destination: CanonicalMessageDestination;
+    content: {
+        text: string;
+    };
+    idempotencyKey: string;
+    threadRootMessageId?: string;
+    embeds?: EntityEmbed[];
+    embedRejections?: WireEmbedRejection[];
+    presentation?: CommunicationPresentation;
+    notificationPolicy?: 'normal' | 'silent';
+    intent: CanonicalIntentEnvelope['intent'];
+}): CanonicalIntentEnvelope;
+export declare function formatEnvelope(envelope: CanonicalIntentEnvelope): string;
+export {};