@canonmsg/backend-contracts 1.9.0 → 2.1.0

package/dist/message.js

@@ -1,68 +1,5 @@
-import { z } from 'zod';
-import { MediaAttachmentSchema, normalizeStoredAttachments } from './media.js';
+import { normalizeStoredAttachments } from './media.js';
 import { decodeStoredRuntimeCard } from './runtimeCardStorage.js';
-export const SerializedSenderTypeSchema = z.enum(['human', 'ai_agent']);
-export const SerializedAgentClientTypeSchema = z.enum([
-    'claude-code',
-    'openclaw',
-    'codex',
-    'hermes',
-    'generic',
-]);
-export const SerializedContentTypeSchema = z.enum([
-    'text',
-    'image',
-    'audio',
-    'video',
-    'file',
-    'contact_card',
-]);
-export const ForwardedFromSchema = z.object({
-    sourceConversationId: z.string(),
-    messageId: z.string(),
-});
-export const SerializedReactionsSchema = z.record(z.string(), z.array(z.string()));
-export const SerializedContactCardSchema = z.object({
-    userId: z.string(),
-    canonContactId: z.string().optional(),
-    displayName: z.string(),
-    avatarUrl: z.string().nullable(),
-    userType: SerializedSenderTypeSchema,
-    clientType: SerializedAgentClientTypeSchema.optional(),
-    about: z.string().optional(),
-    isActive: z.boolean().optional(),
-    ownerId: z.string().optional(),
-    ownerName: z.string().optional(),
-    lifecycleState: z.string().optional(),
-});
-export const SerializedMessageSchema = z.object({
-    id: z.string(),
-    senderId: z.string(),
-    senderName: z.string().optional(),
-    senderType: SerializedSenderTypeSchema,
-    isOwner: z.boolean(),
-    contentType: SerializedContentTypeSchema,
-    text: z.string().nullable(),
-    attachments: z.array(MediaAttachmentSchema),
-    mentions: z.array(z.string()),
-    replyTo: z.string().nullable(),
-    replyToPosition: z.number().nullable(),
-    forwarded: z.boolean().optional(),
-    forwardedFrom: ForwardedFromSchema.optional(),
-    status: z.enum(['sent', 'read']),
-    createdAt: z.string(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    contactCard: SerializedContactCardSchema.optional(),
-    /** Durable canon.card.v1 runtime card content, passed through opaquely. */
-    runtimeCard: z.record(z.string(), z.unknown()).optional(),
-    reactions: SerializedReactionsSchema.optional(),
-});
-export const SerializeMessageInputSchema = z.object({
-    id: z.string(),
-    data: z.record(z.string(), z.unknown()),
-    senderName: z.string().optional(),
-    isOwner: z.boolean(),
-});
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -121,7 +58,8 @@ function normalizeContentType(value) {
         || value === 'audio'
         || value === 'video'
         || value === 'file'
-        || value === 'contact_card') {
+        || value === 'contact_card'
+        || value === 'interaction') {
         return value;
     }
     throw new Error('Message is missing canonical contentType');
@@ -170,6 +108,41 @@ function normalizeContactCard(value) {
         card.lifecycleState = value.lifecycleState;
     return card;
 }
+const INTERACTION_KINDS = [
+    'contact', 'approval', 'input', 'plan', 'card',
+];
+function normalizeInteraction(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (!INTERACTION_KINDS.includes(value.kind))
+        return undefined;
+    if (typeof value.requestId !== 'string' || value.requestId.length === 0)
+        return undefined;
+    const envelope = {
+        kind: value.kind,
+        requestId: value.requestId,
+        interactive: value.interactive === true,
+    };
+    if (typeof value.responseUserId === 'string')
+        envelope.responseUserId = value.responseUserId;
+    if (typeof value.expiresAt === 'string')
+        envelope.expiresAt = value.expiresAt;
+    if (typeof value.schemaVersion === 'string')
+        envelope.schemaVersion = value.schemaVersion;
+    if (isRecord(value.preview)) {
+        const preview = {};
+        if (typeof value.preview.title === 'string')
+            preview.title = value.preview.title;
+        if (Array.isArray(value.preview.blockKinds)) {
+            preview.blockKinds = value.preview.blockKinds.filter((entry) => typeof entry === 'string');
+        }
+        envelope.preview = preview;
+    }
+    if (isRecord(value.response)) {
+        envelope.response = value.response;
+    }
+    return envelope;
+}
 export function serializeStoredMessage(input) {
     const { data } = input;
     const attachments = data.attachments === undefined
@@ -213,6 +186,13 @@ export function serializeStoredMessage(input) {
     if (runtimeCard) {
         result.runtimeCard = runtimeCard;
     }
+    const interaction = normalizeInteraction(data.interaction);
+    if (interaction) {
+        result.interaction = interaction;
+    }
+    if (typeof data.body === 'string') {
+        result.body = data.body;
+    }
     const reactions = normalizeReactions(data.reactions);
     if (reactions) {
         result.reactions = reactions;

package/dist/runtimeCardFields.d.ts

@@ -1,17 +1,4 @@
-import { z } from 'zod';
-export declare const RuntimeCardFieldTypeSchema: z.ZodEnum<{
-    number: "number";
-    boolean: "boolean";
-    date: "date";
-    text: "text";
-    textarea: "textarea";
-    select: "select";
-    multiSelect: "multiSelect";
-    currency: "currency";
-    searchSelect: "searchSelect";
-    lineItems: "lineItems";
-}>;
-export type RuntimeCardFieldType = z.infer<typeof RuntimeCardFieldTypeSchema>;
+export type RuntimeCardFieldType = 'text' | 'textarea' | 'select' | 'multiSelect' | 'boolean' | 'date' | 'number' | 'currency' | 'searchSelect' | 'lineItems';
 /**
  * Caps shared across runtime-card normalizers, response validation, and
  * authoring tools. Keep these backend-safe so Functions can import them.
@@ -22,104 +9,44 @@ export declare const RUNTIME_CARD_LIMITS: {
     readonly lineItemColumns: 8;
     readonly searchSelectChoices: 100;
 };
-export declare const RuntimeCardFieldChoiceSchema: z.ZodObject<{
-    label: z.ZodString;
-    value: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    preview: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type RuntimeCardFieldChoice = z.infer<typeof RuntimeCardFieldChoiceSchema>;
-export declare const RuntimeCardLineItemColumnTypeSchema: z.ZodEnum<{
-    number: "number";
-    date: "date";
-    text: "text";
-    select: "select";
-    currency: "currency";
-}>;
-export type RuntimeCardLineItemColumnType = z.infer<typeof RuntimeCardLineItemColumnTypeSchema>;
-export declare const RuntimeCardLineItemColumnSchema: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    type: z.ZodEnum<{
-        number: "number";
-        date: "date";
-        text: "text";
-        select: "select";
-        currency: "currency";
-    }>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        preview: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    min: z.ZodOptional<z.ZodNumber>;
-    max: z.ZodOptional<z.ZodNumber>;
-    step: z.ZodOptional<z.ZodNumber>;
-    precision: z.ZodOptional<z.ZodNumber>;
-    currencyCode: z.ZodOptional<z.ZodString>;
-    allowOther: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type RuntimeCardLineItemColumn = z.infer<typeof RuntimeCardLineItemColumnSchema>;
-export declare const RuntimeCardFieldSchema: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    type: z.ZodEnum<{
-        number: "number";
-        boolean: "boolean";
-        date: "date";
-        text: "text";
-        textarea: "textarea";
-        select: "select";
-        multiSelect: "multiSelect";
-        currency: "currency";
-        searchSelect: "searchSelect";
-        lineItems: "lineItems";
-    }>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    placeholder: z.ZodOptional<z.ZodString>;
-    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        preview: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    allowOther: z.ZodOptional<z.ZodBoolean>;
-    sensitive: z.ZodOptional<z.ZodBoolean>;
-    min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-    max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-    step: z.ZodOptional<z.ZodNumber>;
-    precision: z.ZodOptional<z.ZodNumber>;
-    currencyCode: z.ZodOptional<z.ZodString>;
-    columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        type: z.ZodEnum<{
-            number: "number";
-            date: "date";
-            text: "text";
-            select: "select";
-            currency: "currency";
-        }>;
-        required: z.ZodOptional<z.ZodBoolean>;
-        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            value: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            preview: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        min: z.ZodOptional<z.ZodNumber>;
-        max: z.ZodOptional<z.ZodNumber>;
-        step: z.ZodOptional<z.ZodNumber>;
-        precision: z.ZodOptional<z.ZodNumber>;
-        currencyCode: z.ZodOptional<z.ZodString>;
-        allowOther: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    minRows: z.ZodOptional<z.ZodNumber>;
-    maxRows: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type RuntimeCardField = z.infer<typeof RuntimeCardFieldSchema>;
+export interface RuntimeCardFieldChoice {
+    label: string;
+    value?: string;
+    description?: string;
+    preview?: string;
+}
+export type RuntimeCardLineItemColumnType = 'text' | 'number' | 'currency' | 'date' | 'select';
+export interface RuntimeCardLineItemColumn {
+    id: string;
+    label: string;
+    type: RuntimeCardLineItemColumnType;
+    required?: boolean;
+    choices?: RuntimeCardFieldChoice[];
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    currencyCode?: string;
+    allowOther?: boolean;
+}
+export interface RuntimeCardField {
+    id: string;
+    label: string;
+    type: RuntimeCardFieldType;
+    required?: boolean;
+    placeholder?: string;
+    choices?: RuntimeCardFieldChoice[];
+    allowOther?: boolean;
+    sensitive?: boolean;
+    min?: number | string;
+    max?: number | string;
+    step?: number;
+    precision?: number;
+    currencyCode?: string;
+    columns?: RuntimeCardLineItemColumn[];
+    minRows?: number;
+    maxRows?: number;
+}
 export declare function validateRuntimeCardFieldValues(input: {
     actionId: string | undefined;
     actionFields: ReadonlyArray<RuntimeCardField> | undefined;

package/dist/runtimeCardFields.js

@@ -1,16 +1,3 @@
-import { z } from 'zod';
-export const RuntimeCardFieldTypeSchema = z.enum([
-    'text',
-    'textarea',
-    'select',
-    'multiSelect',
-    'boolean',
-    'date',
-    'number',
-    'currency',
-    'searchSelect',
-    'lineItems',
-]);
 /**
  * Caps shared across runtime-card normalizers, response validation, and
  * authoring tools. Keep these backend-safe so Functions can import them.
@@ -21,50 +8,6 @@ export const RUNTIME_CARD_LIMITS = {
     lineItemColumns: 8,
     searchSelectChoices: 100,
 };
-export const RuntimeCardFieldChoiceSchema = z.object({
-    label: z.string(),
-    value: z.string().optional(),
-    description: z.string().optional(),
-    preview: z.string().optional(),
-});
-export const RuntimeCardLineItemColumnTypeSchema = z.enum([
-    'text',
-    'number',
-    'currency',
-    'date',
-    'select',
-]);
-export const RuntimeCardLineItemColumnSchema = z.object({
-    id: z.string(),
-    label: z.string(),
-    type: RuntimeCardLineItemColumnTypeSchema,
-    required: z.boolean().optional(),
-    choices: z.array(RuntimeCardFieldChoiceSchema).optional(),
-    min: z.number().optional(),
-    max: z.number().optional(),
-    step: z.number().optional(),
-    precision: z.number().optional(),
-    currencyCode: z.string().optional(),
-    allowOther: z.boolean().optional(),
-});
-export const RuntimeCardFieldSchema = z.object({
-    id: z.string(),
-    label: z.string(),
-    type: RuntimeCardFieldTypeSchema,
-    required: z.boolean().optional(),
-    placeholder: z.string().optional(),
-    choices: z.array(RuntimeCardFieldChoiceSchema).optional(),
-    allowOther: z.boolean().optional(),
-    sensitive: z.boolean().optional(),
-    min: z.union([z.number(), z.string()]).optional(),
-    max: z.union([z.number(), z.string()]).optional(),
-    step: z.number().optional(),
-    precision: z.number().optional(),
-    currencyCode: z.string().optional(),
-    columns: z.array(RuntimeCardLineItemColumnSchema).optional(),
-    minRows: z.number().optional(),
-    maxRows: z.number().optional(),
-});
 const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);

package/dist/turnProtocol.d.ts

@@ -1,94 +1,27 @@
-import { z } from 'zod';
-export declare const SenderTypeSchema: z.ZodEnum<{
-    human: "human";
-    ai_agent: "ai_agent";
-}>;
-export type SenderType = z.infer<typeof SenderTypeSchema>;
-export declare const TurnLifecycleStateSchema: z.ZodEnum<{
-    idle: "idle";
-    thinking: "thinking";
-    streaming: "streaming";
-    tool: "tool";
-    waiting_input: "waiting_input";
-    completed: "completed";
-    interrupted: "interrupted";
-}>;
-export type TurnLifecycleState = z.infer<typeof TurnLifecycleStateSchema>;
-export declare const TurnMessageSemanticsSchema: z.ZodEnum<{
-    progress: "progress";
-    turn_complete: "turn_complete";
-    control: "control";
-}>;
-export type TurnMessageSemantics = z.infer<typeof TurnMessageSemanticsSchema>;
-export declare const DeliveryIntentSchema: z.ZodEnum<{
-    queue: "queue";
-    interrupt: "interrupt";
-    interleave: "interleave";
-    stop: "stop";
-}>;
-export type DeliveryIntent = z.infer<typeof DeliveryIntentSchema>;
-export declare const InboundDispositionSchema: z.ZodEnum<{
-    queued: "queued";
-    accepted_now: "accepted_now";
-    interleaved: "interleaved";
-    trigger_suppressed: "trigger_suppressed";
-    rejected: "rejected";
-    cancelled: "cancelled";
-}>;
-export type InboundDisposition = z.infer<typeof InboundDispositionSchema>;
-export declare const TurnMetadataSchema: z.ZodObject<{
-    turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    turnSemantics: z.ZodOptional<z.ZodEnum<{
-        progress: "progress";
-        turn_complete: "turn_complete";
-        control: "control";
-    }>>;
-    deliveryIntent: z.ZodOptional<z.ZodEnum<{
-        queue: "queue";
-        interrupt: "interrupt";
-        interleave: "interleave";
-        stop: "stop";
-    }>>;
-    replyBehavior: z.ZodOptional<z.ZodEnum<{
-        allow_auto_reply: "allow_auto_reply";
-        suppress_auto_reply: "suppress_auto_reply";
-    }>>;
-    inboundDisposition: z.ZodOptional<z.ZodEnum<{
-        queued: "queued";
-        accepted_now: "accepted_now";
-        interleaved: "interleaved";
-        trigger_suppressed: "trigger_suppressed";
-        rejected: "rejected";
-        cancelled: "cancelled";
-    }>>;
-    requestedTurnMode: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type TurnMetadata = z.infer<typeof TurnMetadataSchema>;
-export declare const TriggerDecisionSchema: z.ZodObject<{
-    allow: z.ZodBoolean;
-    semantics: z.ZodEnum<{
-        progress: "progress";
-        turn_complete: "turn_complete";
-        control: "control";
-    }>;
-    reason: z.ZodString;
-}, z.core.$strip>;
-export type TriggerDecision = z.infer<typeof TriggerDecisionSchema>;
-export declare const TurnStateLikeSchema: z.ZodObject<{
-    state: z.ZodEnum<{
-        idle: "idle";
-        thinking: "thinking";
-        streaming: "streaming";
-        tool: "tool";
-        waiting_input: "waiting_input";
-        completed: "completed";
-        interrupted: "interrupted";
-    }>;
-    openedAt: z.ZodOptional<z.ZodNumber>;
-    updatedAt: z.ZodOptional<z.ZodNumber>;
-    turnUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-}, z.core.$strip>;
-export type TurnStateLike = z.infer<typeof TurnStateLikeSchema>;
+export type SenderType = 'human' | 'ai_agent';
+export type TurnLifecycleState = 'idle' | 'thinking' | 'streaming' | 'tool' | 'waiting_input' | 'completed' | 'interrupted';
+export type TurnMessageSemantics = 'progress' | 'turn_complete' | 'control';
+export type DeliveryIntent = 'queue' | 'interrupt' | 'interleave' | 'stop';
+export type InboundDisposition = 'queued' | 'accepted_now' | 'interleaved' | 'trigger_suppressed' | 'rejected' | 'cancelled';
+export interface TurnMetadata {
+    turnId?: string | null;
+    turnSemantics?: TurnMessageSemantics;
+    deliveryIntent?: DeliveryIntent;
+    replyBehavior?: 'allow_auto_reply' | 'suppress_auto_reply';
+    inboundDisposition?: InboundDisposition;
+    requestedTurnMode?: string;
+}
+export interface TriggerDecision {
+    allow: boolean;
+    semantics: TurnMessageSemantics;
+    reason: string;
+}
+export interface TurnStateLike {
+    state: TurnLifecycleState;
+    openedAt?: number;
+    updatedAt?: number;
+    turnUpdatedAt?: number | null;
+}
 export declare const ACTIVE_TURN_STALE_THRESHOLD_MS: number;
 export declare const WAITING_INPUT_STALE_THRESHOLD_MS: number;
 export declare function normalizeTurnMetadata(metadata: unknown): TurnMetadata | null;

package/dist/turnProtocol.js

@@ -1,43 +1,3 @@
-import { z } from 'zod';
-export const SenderTypeSchema = z.enum(['human', 'ai_agent']);
-export const TurnLifecycleStateSchema = z.enum([
-    'idle',
-    'thinking',
-    'streaming',
-    'tool',
-    'waiting_input',
-    'completed',
-    'interrupted',
-]);
-export const TurnMessageSemanticsSchema = z.enum(['progress', 'turn_complete', 'control']);
-export const DeliveryIntentSchema = z.enum(['queue', 'interrupt', 'interleave', 'stop']);
-export const InboundDispositionSchema = z.enum([
-    'queued',
-    'accepted_now',
-    'interleaved',
-    'trigger_suppressed',
-    'rejected',
-    'cancelled',
-]);
-export const TurnMetadataSchema = z.object({
-    turnId: z.string().nullable().optional(),
-    turnSemantics: TurnMessageSemanticsSchema.optional(),
-    deliveryIntent: DeliveryIntentSchema.optional(),
-    replyBehavior: z.enum(['allow_auto_reply', 'suppress_auto_reply']).optional(),
-    inboundDisposition: InboundDispositionSchema.optional(),
-    requestedTurnMode: z.string().optional(),
-});
-export const TriggerDecisionSchema = z.object({
-    allow: z.boolean(),
-    semantics: TurnMessageSemanticsSchema,
-    reason: z.string(),
-});
-export const TurnStateLikeSchema = z.object({
-    state: TurnLifecycleStateSchema,
-    openedAt: z.number().optional(),
-    updatedAt: z.number().optional(),
-    turnUpdatedAt: z.number().nullable().optional(),
-});
 export const ACTIVE_TURN_STALE_THRESHOLD_MS = 30 * 60 * 1000;
 export const WAITING_INPUT_STALE_THRESHOLD_MS = 12 * 60 * 60 * 1000;
 const TURN_SEMANTICS = [

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@canonmsg/backend-contracts",
-  "version": "1.9.0",
+  "version": "2.1.0",
   "description": "Canon backend contract helpers shared by Functions and stream-service",
   "type": "module",
   "main": "dist/cjs/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/index.d.ts"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node -e \"require('fs').mkdirSync('dist/cjs',{recursive:true}); require('fs').writeFileSync('dist/cjs/package.json', JSON.stringify({type:'commonjs'}))\" && node scripts/emit-json-schema.mjs",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node -e \"require('fs').mkdirSync('dist/cjs',{recursive:true}); require('fs').writeFileSync('dist/cjs/package.json', JSON.stringify({type:'commonjs'}))\"",
     "dev": "tsc -p tsconfig.json --watch",
     "test": "vitest run",
     "prepack": "npm run build"
@@ -44,8 +44,5 @@
     "typescript": "~5.7.0",
     "vitest": "^4.1.8"
   },
-  "license": "MIT",
-  "dependencies": {
-    "zod": "^4.4.3"
-  }
+  "license": "MIT"
 }