@canonmsg/backend-contracts 1.7.1 → 1.8.1

package/dist/agentBehaviorPolicy.d.ts

@@ -1,48 +1,89 @@
-export type ParticipationStyle = 'natural' | 'collaborative' | 'mention-first' | 'approval-gated' | 'handoff-only' | 'observer';
-export interface AgentBehaviorSettingsRecord {
-    participationStyle?: ParticipationStyle;
-    allowAgentToAgent?: boolean;
-    allowLongRunningCollaboration?: boolean;
-    requireMentionForGroupReplies?: boolean;
-    maxConsecutiveAgentTurns?: number | null;
-    instructions?: string | null;
-}
-export interface ResolvedAgentBehaviorPolicyRecord {
-    participation: {
-        style: ParticipationStyle;
-        allowAgentToAgent: boolean;
-        allowHumanToAgent: boolean;
-        allowLongRunningCollaboration: boolean;
-        requireMentionForGroupReplies: boolean;
-        maxConsecutiveAgentTurns?: number | null;
-    };
-    instructions: string[];
-    source: {
-        hasAgentDefault: boolean;
-        hasConversationOverride: boolean;
-    };
-}
-export interface ParticipationDecisionInput {
-    conversationType: 'direct' | 'group' | 'unknown';
-    senderType: 'human' | 'ai_agent';
-    isOwner: boolean;
-    mentionedAgent: boolean;
-    recentHumanCount?: number;
-    consecutiveAgentTurns?: number;
-    currentAgentStreakStartedByHuman?: boolean;
-}
-export interface ParticipationHistoryMessage {
-    senderId: string;
-    senderType: 'human' | 'ai_agent';
-    metadata?: unknown;
-}
-export interface ParticipationHistorySnapshot {
-    recentSenderTypes: Array<'human' | 'ai_agent'>;
-    recentHumanCount: number;
-    recentAgentCount: number;
-    consecutiveAgentTurns: number;
-    currentAgentStreakStartedByHuman: boolean;
-}
+import { z } from 'zod';
+export declare const ParticipationStyleSchema: z.ZodEnum<{
+    natural: "natural";
+    collaborative: "collaborative";
+    "mention-first": "mention-first";
+    "approval-gated": "approval-gated";
+    "handoff-only": "handoff-only";
+    observer: "observer";
+}>;
+export type ParticipationStyle = z.infer<typeof ParticipationStyleSchema>;
+export declare const AgentBehaviorSettingsRecordSchema: z.ZodObject<{
+    participationStyle: z.ZodOptional<z.ZodEnum<{
+        natural: "natural";
+        collaborative: "collaborative";
+        "mention-first": "mention-first";
+        "approval-gated": "approval-gated";
+        "handoff-only": "handoff-only";
+        observer: "observer";
+    }>>;
+    allowAgentToAgent: z.ZodOptional<z.ZodBoolean>;
+    allowLongRunningCollaboration: z.ZodOptional<z.ZodBoolean>;
+    requireMentionForGroupReplies: z.ZodOptional<z.ZodBoolean>;
+    maxConsecutiveAgentTurns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    instructions: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type AgentBehaviorSettingsRecord = z.infer<typeof AgentBehaviorSettingsRecordSchema>;
+export declare const ResolvedAgentBehaviorPolicyRecordSchema: z.ZodObject<{
+    participation: z.ZodObject<{
+        style: z.ZodEnum<{
+            natural: "natural";
+            collaborative: "collaborative";
+            "mention-first": "mention-first";
+            "approval-gated": "approval-gated";
+            "handoff-only": "handoff-only";
+            observer: "observer";
+        }>;
+        allowAgentToAgent: z.ZodBoolean;
+        allowHumanToAgent: z.ZodBoolean;
+        allowLongRunningCollaboration: z.ZodBoolean;
+        requireMentionForGroupReplies: z.ZodBoolean;
+        maxConsecutiveAgentTurns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    instructions: z.ZodArray<z.ZodString>;
+    source: z.ZodObject<{
+        hasAgentDefault: z.ZodBoolean;
+        hasConversationOverride: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ResolvedAgentBehaviorPolicyRecord = z.infer<typeof ResolvedAgentBehaviorPolicyRecordSchema>;
+export declare const ParticipationDecisionInputSchema: z.ZodObject<{
+    conversationType: z.ZodEnum<{
+        unknown: "unknown";
+        direct: "direct";
+        group: "group";
+    }>;
+    senderType: z.ZodEnum<{
+        human: "human";
+        ai_agent: "ai_agent";
+    }>;
+    isOwner: z.ZodBoolean;
+    mentionedAgent: z.ZodBoolean;
+    recentHumanCount: z.ZodOptional<z.ZodNumber>;
+    consecutiveAgentTurns: z.ZodOptional<z.ZodNumber>;
+    currentAgentStreakStartedByHuman: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ParticipationDecisionInput = z.infer<typeof ParticipationDecisionInputSchema>;
+export declare const ParticipationHistoryMessageSchema: z.ZodObject<{
+    senderId: z.ZodString;
+    senderType: z.ZodEnum<{
+        human: "human";
+        ai_agent: "ai_agent";
+    }>;
+    metadata: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ParticipationHistoryMessage = z.infer<typeof ParticipationHistoryMessageSchema>;
+export declare const ParticipationHistorySnapshotSchema: z.ZodObject<{
+    recentSenderTypes: z.ZodArray<z.ZodEnum<{
+        human: "human";
+        ai_agent: "ai_agent";
+    }>>;
+    recentHumanCount: z.ZodNumber;
+    recentAgentCount: z.ZodNumber;
+    consecutiveAgentTurns: z.ZodNumber;
+    currentAgentStreakStartedByHuman: z.ZodBoolean;
+}, z.core.$strip>;
+export type ParticipationHistorySnapshot = z.infer<typeof ParticipationHistorySnapshotSchema>;
 export declare const PARTICIPATION_HISTORY_FETCH_LIMIT = 50;
 export declare function parseAgentBehaviorSettings(raw: unknown): AgentBehaviorSettingsRecord;
 export declare function normalizeStoredAgentBehaviorPolicy(raw: Record<string, unknown> | undefined): AgentBehaviorSettingsRecord | null;

package/dist/agentBehaviorPolicy.js

@@ -1,4 +1,57 @@
+import { z } from 'zod';
 import { resolveTurnMessageSemantics } from './turnProtocol.js';
+export const ParticipationStyleSchema = z.enum([
+    'natural',
+    'collaborative',
+    'mention-first',
+    'approval-gated',
+    'handoff-only',
+    'observer',
+]);
+export const AgentBehaviorSettingsRecordSchema = z.object({
+    participationStyle: ParticipationStyleSchema.optional(),
+    allowAgentToAgent: z.boolean().optional(),
+    allowLongRunningCollaboration: z.boolean().optional(),
+    requireMentionForGroupReplies: z.boolean().optional(),
+    maxConsecutiveAgentTurns: z.number().nullable().optional(),
+    instructions: z.string().nullable().optional(),
+});
+export const ResolvedAgentBehaviorPolicyRecordSchema = z.object({
+    participation: z.object({
+        style: ParticipationStyleSchema,
+        allowAgentToAgent: z.boolean(),
+        allowHumanToAgent: z.boolean(),
+        allowLongRunningCollaboration: z.boolean(),
+        requireMentionForGroupReplies: z.boolean(),
+        maxConsecutiveAgentTurns: z.number().nullable().optional(),
+    }),
+    instructions: z.array(z.string()),
+    source: z.object({
+        hasAgentDefault: z.boolean(),
+        hasConversationOverride: z.boolean(),
+    }),
+});
+export const ParticipationDecisionInputSchema = z.object({
+    conversationType: z.enum(['direct', 'group', 'unknown']),
+    senderType: z.enum(['human', 'ai_agent']),
+    isOwner: z.boolean(),
+    mentionedAgent: z.boolean(),
+    recentHumanCount: z.number().optional(),
+    consecutiveAgentTurns: z.number().optional(),
+    currentAgentStreakStartedByHuman: z.boolean().optional(),
+});
+export const ParticipationHistoryMessageSchema = z.object({
+    senderId: z.string(),
+    senderType: z.enum(['human', 'ai_agent']),
+    metadata: z.unknown().optional(),
+});
+export const ParticipationHistorySnapshotSchema = z.object({
+    recentSenderTypes: z.array(z.enum(['human', 'ai_agent'])),
+    recentHumanCount: z.number(),
+    recentAgentCount: z.number(),
+    consecutiveAgentTurns: z.number(),
+    currentAgentStreakStartedByHuman: z.boolean(),
+});
 export const PARTICIPATION_HISTORY_FETCH_LIMIT = 50;
 const VALID_PARTICIPATION_STYLES = new Set([
     'natural',