@canonmsg/agent-sdk 11.2.1 → 12.1.0

package/dist/managed-session-setup.js

@@ -1,234 +0,0 @@
-import { createHash } from 'node:crypto';
-import { execFileSync } from 'node:child_process';
-import { existsSync, realpathSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { buildConversationWorktreeSpec, prepareConversationEnvironment, releaseConversationEnvironment, readLocalRuntimeEntry, saveRuntimeSessionState, } from '@canonmsg/core';
-const SETTING_KEYS = ['projectId', 'modelId', 'reasoningEffort', 'permissionMode', 'executionMode'];
-export const MANAGED_EXECUTION_MODE_LABELS = {
-    worktree: 'Git worktree',
-    locked: 'Project folder',
-};
-export function buildManagedSessionCatalog(input) {
-    const defaults = {
-        ...(input.projects[0] ? { projectId: input.projects[0].id } : {}),
-        ...(input.defaultModelId ? { modelId: input.defaultModelId } : {}),
-        ...(input.defaultReasoningEffort ? { reasoningEffort: input.defaultReasoningEffort } : {}),
-        permissionMode: input.defaultPermissionMode, executionMode: input.defaultExecutionMode,
-    };
-    const catalog = {
-        provider: input.provider, canCreate: false, canAttach: false, managedSetup: { version: 1 },
-        projects: input.projects.map((project) => ({ id: project.id, label: project.label })),
-        models: input.models.map((model) => ({ ...model })),
-        ...(input.reasoningEfforts?.length ? { reasoningEfforts: input.reasoningEfforts.map((effort) => ({ ...effort })) } : {}),
-        permissionModes: input.permissionModes.map((mode) => ({ ...mode })),
-        executionModes: input.executionModes.map((id) => ({ id, label: MANAGED_EXECUTION_MODE_LABELS[id] })),
-        defaults, sessions: [],
-    };
-    return { revision: createHash('sha256').update(JSON.stringify(catalog)).digest('hex').slice(0, 24), ...catalog };
-}
-/** The one saved setup for a conversation, or null; conflicting copies fail closed. */
-export function findManagedSessionState(runtimeId, conversationId, runtime) {
-    const states = Object.values(readLocalRuntimeEntry(runtimeId)?.sessions ?? {})
-        .filter((state) => state.conversationId === conversationId && state.codexManagedSetup);
-    if (states.length > 1)
-        throw new Error(`Conflicting saved ${runtime.label} setup for this conversation.`);
-    return states[0] ?? null;
-}
-export function hasSavedNativeSession(runtimeId, conversationId, resumeField) {
-    return Object.values(readLocalRuntimeEntry(runtimeId)?.sessions ?? {})
-        .some((state) => state.conversationId === conversationId && Boolean(state[resumeField]));
-}
-/** Older records without ownership fields stay usable; a different owner generation does not. */
-export function savedSessionMatchesOwner(state, ownerId, ownershipVersion) {
-    return (state.ownerId === undefined || ownerId === null || state.ownerId === ownerId)
-        && (state.ownershipVersion === undefined || ownershipVersion === undefined
-            || state.ownershipVersion === ownershipVersion);
-}
-export function inspectGitEnvironment(cwd) {
-    const fields = {};
-    try {
-        const branch = execFileSync('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], { cwd, encoding: 'utf8', timeout: 3_000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-        if (branch)
-            fields.branch = { value: branch, provenance: 'observed' };
-    }
-    catch { /* Detached HEAD has no branch to report. */ }
-    try {
-        const [gitDir, commonDir] = execFileSync('git', ['rev-parse', '--path-format=absolute', '--git-dir', '--git-common-dir'], { cwd, encoding: 'utf8', timeout: 3_000, stdio: ['ignore', 'pipe', 'ignore'] })
-            .trim().split(/\r?\n/);
-        if (gitDir && commonDir && realpathSync(gitDir) !== realpathSync(commonDir)) {
-            const path = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', timeout: 3_000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-            if (path)
-                fields.worktreePath = { value: realpathSync(path), provenance: 'observed' };
-        }
-    }
-    catch { /* An unavailable Git path has no worktree observation. */ }
-    return fields;
-}
-function applyConfiguredFacts(fields, facts) {
-    if (facts?.sandbox)
-        fields.sandbox = { value: facts.sandbox, provenance: 'configured' };
-    if (facts?.approvalPolicy)
-        fields.approvalPolicy = { value: facts.approvalPolicy, provenance: 'configured' };
-    if (facts?.nativeThreadBehavior) {
-        fields.nativeThreadBehavior = { value: facts.nativeThreadBehavior, provenance: 'configured' };
-    }
-}
-/** Private owner details for a running session: confirmed settings, then what the runtime and Git observe. */
-export function managedSessionFields(input) {
-    const fields = {};
-    for (const key of SETTING_KEYS) {
-        if (input.settings[key])
-            fields[key] = { value: input.settings[key], provenance: 'configured' };
-    }
-    if (input.projectLabel)
-        fields.projectLabel = { value: input.projectLabel, provenance: 'configured' };
-    fields.workingDirectory = { value: realpathSync(input.cwd), provenance: 'observed' };
-    applyConfiguredFacts(fields, input.configured);
-    if (input.observedModel)
-        fields.modelId = { value: input.observedModel, provenance: 'observed' };
-    if (input.observedEffort)
-        fields.reasoningEffort = { value: input.observedEffort, provenance: 'observed' };
-    Object.assign(fields, inspectGitEnvironment(input.cwd));
-    return fields;
-}
-/** Private details for a running session nobody set up: what the host and Git observe. */
-export function observedSessionFields(input) {
-    const fields = { workingDirectory: { value: input.cwd, provenance: 'observed' } };
-    if (input.executionMode)
-        fields.executionMode = { value: input.executionMode, provenance: 'observed' };
-    if (input.project) {
-        fields.projectId = { value: input.project.id, provenance: 'observed' };
-        fields.projectLabel = { value: input.project.label, provenance: 'observed' };
-    }
-    if (input.observedModel)
-        fields.modelId = { value: input.observedModel, provenance: 'observed' };
-    if (input.observedEffort)
-        fields.reasoningEffort = { value: input.observedEffort, provenance: 'observed' };
-    Object.assign(fields, inspectGitEnvironment(input.cwd));
-    return fields;
-}
-/** Read only: details for a saved session with no live native process, if its directory still exists. */
-export function savedSessionFields(input) {
-    const { state } = input;
-    const configured = state.codexManagedSetup?.settings;
-    const project = input.projects.find((entry) => entry.cwd === state.baseCwd);
-    let cwd;
-    if (state.executionMode === 'locked' && existsSync(state.baseCwd))
-        cwd = state.baseCwd;
-    if (state.executionMode === 'worktree') {
-        try {
-            const spec = buildConversationWorktreeSpec({ agentId: input.agentId,
-                conversationId: state.conversationId, workspaceCwd: state.baseCwd });
-            const root = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: state.baseCwd, encoding: 'utf8', timeout: 3_000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-            const candidate = join(spec.worktreePath, relative(root, state.baseCwd));
-            if (existsSync(candidate))
-                cwd = candidate;
-        }
-        catch { /* Unavailable path stays unreported. */ }
-    }
-    const facts = configured ? input.describeConfigured?.(configured) : undefined;
-    if (configured && cwd) {
-        return managedSessionFields({ settings: configured, cwd, projectLabel: project?.label, configured: facts });
-    }
-    const fields = {};
-    if (configured) {
-        for (const key of SETTING_KEYS) {
-            if (configured[key])
-                fields[key] = { value: configured[key], provenance: 'configured' };
-        }
-        if (project?.label)
-            fields.projectLabel = { value: project.label, provenance: 'configured' };
-        applyConfiguredFacts(fields, facts);
-    }
-    else {
-        if (state.executionMode)
-            fields.executionMode = { value: state.executionMode, provenance: 'observed' };
-        if (project) {
-            fields.projectId = { value: project.id, provenance: 'observed' };
-            fields.projectLabel = { value: project.label, provenance: 'observed' };
-        }
-    }
-    if (cwd) {
-        fields.workingDirectory = { value: realpathSync(cwd), provenance: 'observed' };
-        Object.assign(fields, inspectGitEnvironment(cwd));
-    }
-    return fields;
-}
-/**
- * Idempotent configuration for `createCanonManagedSessionHost`. Validates the
- * owner's selection against the catalog, prepares the requested environment
- * (a requested worktree that cannot be created fails instead of falling back)
- * and saves the setup before the broker is acknowledged. A replayed request
- * returns the saved setup; a conversation that already has a native session or
- * a different confirmed setup keeps it.
- */
-export function configureManagedSession(input) {
-    const { runtime } = input;
-    const selection = input.request.selection;
-    if (selection.mode !== 'configure' || input.catalog.managedSetup?.version !== 1)
-        throw new Error('This host does not support the requested setup.');
-    const existing = findManagedSessionState(input.runtimeId, input.request.conversationId, runtime);
-    if (existing?.codexManagedSetup) {
-        if (!savedSessionMatchesOwner(existing, input.ownerId ?? null, input.ownershipVersion))
-            throw new Error(`The saved ${runtime.label} setup belongs to a previous owner generation.`);
-        if (existing.codexManagedSetup.requestId !== input.request.requestId)
-            throw new Error(`This conversation already has a confirmed ${runtime.label} setup.`);
-        const settings = existing.codexManagedSetup.settings;
-        const environment = prepareConversationEnvironment({ agentId: input.agentId,
-            conversationId: input.request.conversationId, workspaceCwd: existing.baseCwd,
-            allowWorktrees: existing.executionMode === 'worktree' });
-        try {
-            if (environment.mode !== existing.executionMode)
-                throw new Error(`The saved ${runtime.label} execution environment is unavailable.`);
-            return { settings,
-                fields: managedSessionFields({ settings, cwd: environment.cwd,
-                    projectLabel: input.projects.find((project) => project.id === settings.projectId)?.label,
-                    configured: input.describeConfigured?.(settings) }),
-            };
-        }
-        finally {
-            releaseConversationEnvironment(environment);
-        }
-    }
-    if (hasSavedNativeSession(input.runtimeId, input.request.conversationId, runtime.resumeField))
-        throw new Error(`This conversation already has a native ${runtime.label} ${runtime.nativeSession}. Its settings are preserved.`);
-    const project = input.projects.find((entry) => entry.id === selection.projectId);
-    if (!project)
-        throw new Error('The selected project is unavailable on this host.');
-    const modelId = selection.modelId ?? input.catalog.defaults?.modelId;
-    const model = input.catalog.models?.find((entry) => entry.id === modelId);
-    if (modelId && !model)
-        throw new Error('The selected model is unavailable on this host.');
-    const reasoningEffort = selection.reasoningEffort ?? input.catalog.defaults?.reasoningEffort;
-    if (reasoningEffort && !(model?.reasoningEfforts?.length ? model.reasoningEfforts : input.catalog.reasoningEfforts ?? [])
-        .some((entry) => entry.id === reasoningEffort))
-        throw new Error('The selected thinking level is unavailable for this model.');
-    const permissionMode = selection.permissionMode ?? input.catalog.defaults?.permissionMode;
-    const executionMode = selection.executionMode ?? input.catalog.defaults?.executionMode;
-    if (!permissionMode || !input.catalog.permissionModes?.some((entry) => entry.id === permissionMode)
-        || !executionMode || !input.catalog.executionModes?.some((entry) => entry.id === executionMode))
-        throw new Error('The selected execution policy is unavailable on this host.');
-    if (input.isPermissionModeApplicable && !input.isPermissionModeApplicable(permissionMode, modelId))
-        throw new Error('The selected permission policy cannot be applied.');
-    const environment = prepareConversationEnvironment({ agentId: input.agentId,
-        conversationId: input.request.conversationId, workspaceCwd: project.cwd,
-        allowWorktrees: executionMode === 'worktree' });
-    try {
-        if (environment.mode !== executionMode)
-            throw new Error('The requested Git worktree could not be created. Select Project folder explicitly to use the base project.');
-        const settings = { projectId: project.id,
-            ...(modelId ? { modelId } : {}), ...(reasoningEffort ? { reasoningEffort } : {}),
-            permissionMode, executionMode };
-        const fields = managedSessionFields({ settings, cwd: environment.cwd, projectLabel: project.label,
-            configured: input.describeConfigured?.(settings) });
-        saveRuntimeSessionState(input.runtimeId, { conversationId: input.request.conversationId,
-            baseCwd: environment.baseCwd, executionMode: executionMode,
-            ...(input.ownerId ? { ownerId: input.ownerId } : {}),
-            ...(input.ownershipVersion !== undefined ? { ownershipVersion: input.ownershipVersion } : {}),
-            codexManagedSetup: { requestId: input.request.requestId, settings } });
-        return { settings, fields };
-    }
-    finally {
-        releaseConversationEnvironment(environment);
-    }
-}

package/dist/realtime.d.ts

@@ -1,62 +0,0 @@
-import { type CanonEndpoint, type AgentContext, type ContactAddedPayload, type ContactRemovedPayload, type ConversationUpdatedPayload, type MessageUpdatedPayload, type ParticipationSuppressedPayload, type VoiceSessionEventPayload } from '@canonmsg/core';
-import { Debouncer } from './debouncer.js';
-/**
- * Wraps @canonmsg/core's CanonStream with SDK-specific features:
- * - Debouncer integration (message batching)
- * - Agent context callback
- * - Connection/status callbacks
- */
-export declare class RealtimeManager {
-    private debouncer;
-    private stream;
-    private readonly endpoint;
-    private readonly inbound;
-    private lastSseErrorKey;
-    private lastSseErrorAt;
-    private suppressedSseErrorCount;
-    private onAgentContext;
-    private onContactAdded;
-    private onContactRemoved;
-    private onConversationUpdated;
-    private onParticipationSuppressed;
-    private onMessageUpdated;
-    private onMessageDeleted;
-    private onConnected;
-    private onDisconnected;
-    private onCallStarted;
-    private onCallEnded;
-    constructor(apiKey: string, debouncer: Debouncer, agentId: string, streamUrl: string | undefined, options: {
-        enableVoiceEvents?: boolean;
-        endpoint: CanonEndpoint;
-    });
-    private receive;
-    private offer;
-    private logSseError;
-    setOnAgentContext(cb: (ctx: AgentContext) => void): void;
-    setContactGraphHandlers(handlers: {
-        onContactAdded?: (payload: ContactAddedPayload) => void;
-        onContactRemoved?: (payload: ContactRemovedPayload) => void;
-    }): void;
-    setConversationUpdatedHandler(cb: (payload: ConversationUpdatedPayload) => void): void;
-    /**
-     * Observe-only notice that Canon's participation gate withheld a turn this
-     * agent would otherwise have been dispatched. Never run a turn off it — it
-     * exists so an agent can tell deliberate policy from a dead stream.
-     */
-    setParticipationSuppressedHandler(cb: (payload: ParticipationSuppressedPayload) => void): void;
-    setMessageUpdatedHandler(cb: (payload: MessageUpdatedPayload) => void): void;
-    setMessageDeletedHandler(cb: (payload: {
-        conversationId: string;
-        messageId: string;
-    }) => void): void;
-    setConnectionHandlers(handlers: {
-        onConnected?: () => void;
-        onDisconnected?: () => void;
-    }): void;
-    setCallHandlers(handlers: {
-        onCallStarted?: (payload: VoiceSessionEventPayload) => void;
-        onCallEnded?: (payload: VoiceSessionEventPayload) => void;
-    }): void;
-    start(): Promise<void>;
-    stop(): void;
-}

package/dist/realtime.js

@@ -1,193 +0,0 @@
-import { CanonStream, } from '@canonmsg/core';
-/**
- * Wraps @canonmsg/core's CanonStream with SDK-specific features:
- * - Debouncer integration (message batching)
- * - Agent context callback
- * - Connection/status callbacks
- */
-export class RealtimeManager {
-    debouncer;
-    stream;
-    endpoint;
-    inbound;
-    lastSseErrorKey = null;
-    lastSseErrorAt = 0;
-    suppressedSseErrorCount = 0;
-    onAgentContext = null;
-    onContactAdded = null;
-    onContactRemoved = null;
-    onConversationUpdated = null;
-    onParticipationSuppressed = null;
-    onMessageUpdated = null;
-    onMessageDeleted = null;
-    onConnected = null;
-    onDisconnected = null;
-    onCallStarted = null;
-    onCallEnded = null;
-    constructor(apiKey, debouncer, agentId, streamUrl, options) {
-        this.debouncer = debouncer;
-        this.endpoint = options.endpoint;
-        this.inbound = this.endpoint.acceptInbound({ kind: 'message.created',
-            offer: (event) => this.offer(event.data),
-            onError: (error) => this.logSseError(error instanceof Error ? error : new Error(String(error))), });
-        this.stream = new CanonStream({
-            endpoint: this.endpoint,
-            agentId,
-            handler: {
-                // The voice family is requested from handler PRESENCE at stream
-                // construction, so these delegating closures exist only when the
-                // agent registered call handlers before connect — otherwise every
-                // SDK agent would cost the stream service a per-conversation
-                // voiceSessions listener for nothing.
-                ...(options?.enableVoiceEvents
-                    ? {
-                        onVoiceSessionStarted: (payload) => {
-                            this.onCallStarted?.(payload);
-                        },
-                        onVoiceSessionEnded: (payload) => {
-                            this.onCallEnded?.(payload);
-                        },
-                    }
-                    : {}),
-                onMessage: (payload) => {
-                    void this.receive(payload).catch((error) => this.logSseError(error instanceof Error ? error : new Error(String(error))));
-                },
-                onMessageDeleted: (payload) => {
-                    this.debouncer.removeMessage(payload.conversationId, payload.messageId);
-                    this.onMessageDeleted?.(payload);
-                },
-                onMessageUpdated: (payload) => {
-                    this.onMessageUpdated?.(payload);
-                },
-                onAgentContext: (ctx) => {
-                    this.onAgentContext?.(ctx);
-                },
-                onContactAdded: (payload) => {
-                    this.onContactAdded?.(payload);
-                },
-                onContactRemoved: (payload) => {
-                    this.onContactRemoved?.(payload);
-                },
-                onConversationUpdated: (payload) => {
-                    void this.endpoint.applyConversationSnapshot({ id: payload.conversationId, ...payload.changes })
-                        .then(({ id: _id, ...changes }) => this.onConversationUpdated?.({ ...payload, changes }))
-                        .catch((error) => this.logSseError(error instanceof Error ? error : new Error(String(error))));
-                },
-                onParticipationSuppressed: (payload) => {
-                    this.onParticipationSuppressed?.(payload);
-                },
-                onConnected: () => {
-                    this.onConnected?.();
-                },
-                onDisconnected: () => {
-                    this.onDisconnected?.();
-                },
-                onReplayExpired: (payload) => {
-                    console.error(`[canon-sdk] SSE replay window expired${payload.lastAvailableId ? ` (oldest available event: ${payload.lastAvailableId})` : ''}; the endpoint is recovering the durable gap`);
-                },
-                onError: (err) => {
-                    this.logSseError(err);
-                },
-            },
-        });
-    }
-    async receive(payload) {
-        await this.inbound.receive({ id: `message:${payload.conversationId}:${payload.message.id}`,
-            kind: 'message.created', conversationId: payload.conversationId, durable: true,
-            data: payload });
-    }
-    async offer(payload) {
-        const id = `message:${payload.conversationId}:${payload.message.id}`;
-        const handoff = await this.endpoint.acquireInbound(id);
-        if (!handoff)
-            return;
-        if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
-            await handoff.cancel('observe-only');
-            return;
-        }
-        const m = payload.message;
-        const message = {
-            id: m.id,
-            senderId: m.senderId,
-            ...(m.senderName ? { senderName: m.senderName } : {}),
-            senderType: m.senderType ?? 'human',
-            isOwner: m.isOwner ?? false,
-            contentType: m.contentType ?? 'text',
-            text: m.text ?? null,
-            attachments: m.attachments ?? [],
-            mentions: m.mentions ?? [],
-            ...(m.reactions ? { reactions: m.reactions } : {}),
-            replyTo: m.replyTo ?? null,
-            replyToPosition: m.replyToPosition ?? null,
-            ...(m.forwarded === true || m.forwardedFrom
-                ? { forwarded: true }
-                : {}),
-            ...(m.forwardedFrom
-                ? { forwardedFrom: m.forwardedFrom }
-                : {}),
-            status: 'sent',
-            deleted: false,
-            createdAt: m.createdAt ?? new Date().toISOString(),
-            ...(m.contactCard ? { contactCard: m.contactCard } : {}),
-            ...(m.metadata ? { metadata: m.metadata } : {}),
-            ...(payload.replyAuthority ? { replyAuthority: payload.replyAuthority } : {}),
-        };
-        this.debouncer.add(payload.conversationId, message, payload.provenance ?? null, handoff);
-    }
-    logSseError(err) {
-        const code = err.code;
-        const key = `${typeof code === 'string' ? code : 'generic'}:${err.message}`;
-        const now = Date.now();
-        if (this.lastSseErrorKey === key && now - this.lastSseErrorAt < 60_000) {
-            this.suppressedSseErrorCount += 1;
-            return;
-        }
-        if (this.suppressedSseErrorCount > 0) {
-            console.error(`[canon-sdk] SSE error repeated ${this.suppressedSseErrorCount} more time${this.suppressedSseErrorCount === 1 ? '' : 's'}`);
-            this.suppressedSseErrorCount = 0;
-        }
-        this.lastSseErrorKey = key;
-        this.lastSseErrorAt = now;
-        console.error('[canon-sdk] SSE error:', err.message);
-    }
-    setOnAgentContext(cb) {
-        this.onAgentContext = cb;
-    }
-    setContactGraphHandlers(handlers) {
-        this.onContactAdded = handlers.onContactAdded ?? null;
-        this.onContactRemoved = handlers.onContactRemoved ?? null;
-    }
-    setConversationUpdatedHandler(cb) {
-        this.onConversationUpdated = cb;
-    }
-    /**
-     * Observe-only notice that Canon's participation gate withheld a turn this
-     * agent would otherwise have been dispatched. Never run a turn off it — it
-     * exists so an agent can tell deliberate policy from a dead stream.
-     */
-    setParticipationSuppressedHandler(cb) {
-        this.onParticipationSuppressed = cb;
-    }
-    setMessageUpdatedHandler(cb) {
-        this.onMessageUpdated = cb;
-    }
-    setMessageDeletedHandler(cb) {
-        this.onMessageDeleted = cb;
-    }
-    setConnectionHandlers(handlers) {
-        this.onConnected = handlers.onConnected ?? null;
-        this.onDisconnected = handlers.onDisconnected ?? null;
-    }
-    setCallHandlers(handlers) {
-        this.onCallStarted = handlers.onCallStarted ?? null;
-        this.onCallEnded = handlers.onCallEnded ?? null;
-    }
-    async start() {
-        this.inbound.start();
-        await this.stream.start();
-    }
-    stop() {
-        void this.inbound.close();
-        this.stream.stop();
-    }
-}

package/dist/runtime-card.d.ts

@@ -1,48 +0,0 @@
-import type { RuntimeCardNativeMetadata, RuntimeCardV1 } from '@canonmsg/core';
-import type { RuntimeCardRequest } from './types';
-export declare const DEFAULT_RUNTIME_INPUT_TIMEOUT_MS: number;
-export declare const RUNTIME_INPUT_ID_PATTERN: RegExp;
-export declare function normalizeResponseUserId(value: string | undefined): string | undefined;
-/**
- * Resolve the routing prelude shared verbatim by `sendCard` (display) and
- * `requestCard` (interactive): the sanitized card id, the effective expiry,
- * and the request with an explicit responder folded in.
- *
- * `triggeringHumanId` must be passed in by the caller rather than re-derived
- * here — it is captured from the enclosing message handler's scope.
- */
-export declare function resolveRuntimeCardRouting(input: {
-    request: RuntimeCardRequest;
-    triggeringHumanId?: string;
-}): {
-    cardId: string;
-    expiresAtMs: number;
-    routedRequest: RuntimeCardRequest;
-};
-/** Arguments passed to `CanonClient.createRuntimeCardRequest`. */
-export interface RuntimeCardCreateArgs {
-    conversationId: string;
-    card: RuntimeCardV1;
-    cardId: string;
-    expiresAt: number;
-    responseUserId?: string;
-    runtimeId?: string;
-    turnId?: string;
-    native?: RuntimeCardNativeMetadata;
-}
-/**
- * Build the `createRuntimeCardRequest` payload shared by `sendCard` (display)
- * and `requestCard` (interactive).
- *
- * `responseUserId` is OMITTED unless the developer supplied one, so the Canon
- * backend infers a reachable responder (the owner when they are a conversation
- * member, otherwise the sole other member). Pre-filling the owner here would
- * break agent-to-user DMs where the owner is not a member of the conversation.
- */
-export declare function buildRuntimeCardCreateArgs(input: {
-    request: RuntimeCardRequest;
-    conversationId: string;
-    cardId: string;
-    fallbackTurnId?: string;
-    expiresAtMs: number;
-}): RuntimeCardCreateArgs;

package/dist/runtime-card.js

@@ -1,64 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export const DEFAULT_RUNTIME_INPUT_TIMEOUT_MS = 5 * 60_000;
-export const RUNTIME_INPUT_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,160}$/;
-function safeRuntimeCardId(value) {
-    const raw = value?.trim() || `card_${randomUUID()}`;
-    const normalized = raw.replace(/[.#$\[\]\/\s]+/g, '_').slice(0, 80);
-    return RUNTIME_INPUT_ID_PATTERN.test(normalized)
-        ? normalized
-        : `card_${randomUUID()}`;
-}
-export function normalizeResponseUserId(value) {
-    return value?.trim() || undefined;
-}
-/**
- * Resolve the routing prelude shared verbatim by `sendCard` (display) and
- * `requestCard` (interactive): the sanitized card id, the effective expiry,
- * and the request with an explicit responder folded in.
- *
- * `triggeringHumanId` must be passed in by the caller rather than re-derived
- * here — it is captured from the enclosing message handler's scope.
- */
-export function resolveRuntimeCardRouting(input) {
-    const { request, triggeringHumanId } = input;
-    const cardId = safeRuntimeCardId(request.cardId ?? request.card.cardId);
-    const explicitExpiresAt = request.expiresAt instanceof Date
-        ? request.expiresAt.getTime()
-        : typeof request.expiresAt === 'number'
-            ? request.expiresAt
-            : typeof request.expiresAt === 'string'
-                ? Date.parse(request.expiresAt)
-                : null;
-    const timeoutMs = Math.max(1_000, request.timeoutMs ?? DEFAULT_RUNTIME_INPUT_TIMEOUT_MS);
-    const expiresAtMs = explicitExpiresAt && Number.isFinite(explicitExpiresAt)
-        ? explicitExpiresAt
-        : Date.now() + timeoutMs;
-    const responseUserId = normalizeResponseUserId(request.responseUserId)
-        ?? triggeringHumanId;
-    const routedRequest = responseUserId
-        ? { ...request, responseUserId }
-        : request;
-    return { cardId, expiresAtMs, routedRequest };
-}
-/**
- * Build the `createRuntimeCardRequest` payload shared by `sendCard` (display)
- * and `requestCard` (interactive).
- *
- * `responseUserId` is OMITTED unless the developer supplied one, so the Canon
- * backend infers a reachable responder (the owner when they are a conversation
- * member, otherwise the sole other member). Pre-filling the owner here would
- * break agent-to-user DMs where the owner is not a member of the conversation.
- */
-export function buildRuntimeCardCreateArgs(input) {
-    const { request, conversationId, cardId, fallbackTurnId, expiresAtMs } = input;
-    return {
-        conversationId,
-        cardId,
-        card: { ...request.card, cardId },
-        expiresAt: expiresAtMs,
-        ...(request.responseUserId ? { responseUserId: request.responseUserId } : {}),
-        ...(request.runtimeId ? { runtimeId: request.runtimeId } : {}),
-        turnId: request.turnId ?? fallbackTurnId,
-        ...(request.native ? { native: request.native } : {}),
-    };
-}