@sidurijs/core 1.0.0

package/dist/intent-classifier.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSearchKeywords = extractSearchKeywords;
+exports.classifyInputIntent = classifyInputIntent;
+exports.classifyInputIntentAsync = classifyInputIntentAsync;
+const teaching_1 = require("./teaching");
+/**
+ * Strips conversational syntax, companion invocations, and question carrier phrases
+ * to extract targeted keyword search terms (e.g., "Siduri, who is Sandrone" -> ["Sandrone"]).
+ */
+function extractSearchKeywords(text, companionName, recentHistory) {
+    if (!text || !text.trim())
+        return [];
+    let query = text.trim();
+    // 1. Strip companion names (e.g. "Companion", "Siduri", "Hey companion,")
+    const companionTokens = ['companion', 'siduri'];
+    if (typeof companionName === 'string' && companionName.trim()) {
+        companionTokens.push(companionName.trim().toLowerCase());
+    }
+    for (const comp of companionTokens) {
+        const compRegex = new RegExp(`^(?:hey|hi|hello)?\\s*${comp}\\b[,:]?\\s*`, 'i');
+        query = query.replace(compRegex, '');
+        const compEndRegex = new RegExp(`[,:]?\\s*${comp}\\s*[.!?]?$`, 'i');
+        query = query.replace(compEndRegex, '');
+    }
+    // 2. Strip leading conversational intent carriers / question frames
+    const prefixPatterns = [
+        /^(?:can\s+you\s+)?(?:please\s+)?(?:tell\s+me\s+(?:all\s+)?about|explain|describe)\s+(?:the\s+)?/i,
+        /^(?:do\s+you\s+know\s+(?:about|who|what)\s+(?:is\s+)?(?:the\s+)?)/i,
+        /^(?:what\s+do\s+you\s+know\s+about\s+(?:the\s+)?)/i,
+        /^(?:who\s+(?:is|was|are|were)\s+(?:the\s+)?)/i,
+        /^(?:what\s+(?:is|was|are|were)\s+(?:the\s+)?)/i,
+        /^(?:where\s+(?:is|was|are|were)\s+(?:the\s+)?)/i,
+        /^(?:when\s+(?:is|was|are|were|will|does)\s+(?:the\s+)?)/i,
+        /^(?:search\s+(?:for\s+)?(?:the\s+)?)/i,
+        /^(?:look\s+up\s+(?:the\s+)?)/i,
+        /^(?:give\s+me\s+(?:info|information|details)\s+(?:on|about)\s+(?:the\s+)?)/i,
+    ];
+    for (const pattern of prefixPatterns) {
+        query = query.replace(pattern, '');
+    }
+    // 3. Strip trailing question marks, quotes, and punctuation
+    query = query.replace(/[?.,!;:'"]+$/g, '').replace(/^[?.,!;:'"]+/g, '').trim();
+    // 4. Resolve pronouns from conversation history if present
+    const hasPronoun = /\b(?:she|he|they|her|him|it)\b/i.test(query);
+    if (hasPronoun && Array.isArray(recentHistory) && recentHistory.length > 0) {
+        for (let i = recentHistory.length - 1; i >= 0; i--) {
+            const prevContent = recentHistory[i].content || '';
+            const prevClean = prevContent.replace(/^(?:who\s+is|what\s+is|where\s+is)\s+/i, '').replace(/[?.,!;:'"]+$/g, '').trim();
+            if (prevClean && !/\b(?:she|he|they|it)\b/i.test(prevClean)) {
+                const firstToken = prevClean.split(/\s+/)[0].replace(/[^a-zA-Z0-9]/g, '');
+                if (firstToken && firstToken.length >= 3) {
+                    // Extract remaining qualifier keywords from current question (e.g. "banner", "build", "lore")
+                    const qualifiers = query.split(/\s+/).filter((w) => !/\b(?:she|he|they|her|him|it)\b/i.test(w) && w.length >= 3);
+                    if (qualifiers.length > 0) {
+                        return [`${firstToken} ${qualifiers.join(' ')}`, firstToken];
+                    }
+                    return [firstToken];
+                }
+            }
+        }
+    }
+    // 5. Return clean keyword if valid
+    if (query.length > 0) {
+        return [query];
+    }
+    return [];
+}
+/**
+ * Evaluates domain heuristics and intent classification for user messages.
+ * Determines if deterministic teaching is present, resolves the effective
+ * interaction mode (casual, teach, hybrid), and determines if external knowledge
+ * retrieval is appropriate.
+ */
+function classifyInputIntent(text, context, overrides) {
+    const normalizedMessage = text.replace(/\s+/g, ' ').trim().toLowerCase();
+    const explicitTeaching = (0, teaching_1.extractDeterministicTeaching)(text, context);
+    const isTeachingLike = overrides?.isTeachingLike ??
+        (context.mode === 'teach' ||
+            explicitTeaching.claims.length > 0 ||
+            explicitTeaching.behaviorProposals.length > 0 ||
+            /\b(?:remember that|remember:|my name is|call me)\b/i.test(normalizedMessage));
+    const isSelfIdentityRequest = overrides?.isSelfIdentityRequest ??
+        /\b(?:who|what) are you\b|\bwho (?:is|are) (?:siduri|companion|the companion|she|he|her|him)\b|\b(?:your|my) name\b|\bdo you (?:know|remember|recognize) me\b|\bwho am i\b|\btell me about yourself\b|\bdescribe yourself\b|\bwhat is your origin\b|\bwho created you\b|\bwho made you\b|\bintroduce yourself\b/.test(normalizedMessage);
+    const isGreeting = overrides?.isGreeting ??
+        /^(?:hello|hi|hey|greetings|good morning|good afternoon|good evening|howdy|yo)[.!]?$/.test(normalizedMessage);
+    const shouldQueryKnowledge = typeof overrides?.shouldQueryKnowledge === 'boolean'
+        ? overrides.shouldQueryKnowledge
+        : (!isTeachingLike && !isSelfIdentityRequest && !isGreeting);
+    const rawKeywords = extractSearchKeywords(text, context.companionId, context.history);
+    const aiKnowledgeQueries = (overrides?.knowledgeQueries || []).filter(Boolean);
+    const knowledgeQueries = aiKnowledgeQueries.length > 0
+        ? Array.from(new Set([...aiKnowledgeQueries, ...rawKeywords]))
+        : (shouldQueryKnowledge ? rawKeywords : []);
+    const primaryQuery = knowledgeQueries[0] || (shouldQueryKnowledge ? text.trim() : undefined);
+    const memoryQueries = (overrides?.memoryQueries && overrides.memoryQueries.length > 0)
+        ? overrides.memoryQueries
+        : rawKeywords;
+    // Multi-tier Interaction Mode Resolution:
+    // 1. Overrides / Cognitive Classifier
+    // 2. Security Boundary: public channel or external source forces 'casual' (Zero Memory Drift)
+    // 3. Explicit Request Mode (context.mode: 'casual' | 'teach' | 'hybrid')
+    // 4. Default companion baseline: 'hybrid' (salience filtering)
+    let effectiveMode;
+    if (overrides?.effectiveMode) {
+        effectiveMode = overrides.effectiveMode;
+    }
+    else if (context.conversation?.channel === 'public' || context.source === 'external') {
+        effectiveMode = 'casual';
+    }
+    else if (context.mode) {
+        effectiveMode = context.mode;
+    }
+    else {
+        effectiveMode = 'hybrid';
+    }
+    return {
+        normalizedMessage,
+        explicitTeaching,
+        isTeachingLike,
+        isSelfIdentityRequest,
+        isGreeting,
+        shouldQueryKnowledge,
+        knowledgeQueries,
+        primaryQuery,
+        memoryQueries,
+        effectiveMode,
+        confidence: overrides?.confidence ?? 0.95,
+        classifierOrigin: overrides?.classifierOrigin ?? 'heuristic',
+    };
+}
+/**
+ * Asynchronously classifies intent, allowing an EarOrgan or cognitive model
+ * to provide semantic classification before falling back to heuristics.
+ */
+async function classifyInputIntentAsync(text, context, classifier) {
+    if (!classifier) {
+        return classifyInputIntent(text, context);
+    }
+    try {
+        const cognitiveResult = await classifier(text, context);
+        return classifyInputIntent(text, context, {
+            ...cognitiveResult,
+            classifierOrigin: cognitiveResult.classifierOrigin || 'cognitive',
+        });
+    }
+    catch (err) {
+        return classifyInputIntent(text, context);
+    }
+}

package/dist/intent-classifier.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/intent-classifier.test.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const intent_classifier_1 = require("./intent-classifier");
+describe('IntentClassifier', () => {
+    const dummyContext = {
+        companionId: 'test-comp',
+        actor: {
+            actorId: 'user-1',
+            sessionId: 'sess-1',
+            authorizationRole: 'administrator',
+            capabilities: ['chat:public'],
+            authenticated: true,
+        },
+        conversation: {
+            channel: 'direct',
+            correlationId: 'corr-1',
+        },
+    };
+    test('classifies greetings correctly and suppresses knowledge queries', () => {
+        const greetings = ['Hello', 'hi', 'Good morning', 'greetings!'];
+        for (const g of greetings) {
+            const result = (0, intent_classifier_1.classifyInputIntent)(g, dummyContext);
+            expect(result.isGreeting).toBe(true);
+            expect(result.shouldQueryKnowledge).toBe(false);
+        }
+    });
+    test('classifies self-identity inquiries and suppresses knowledge queries', () => {
+        const identityQuestions = [
+            'Who are you?',
+            'What are you',
+            'who is siduri',
+            'Tell me about yourself',
+            'what is your name',
+        ];
+        for (const q of identityQuestions) {
+            const result = (0, intent_classifier_1.classifyInputIntent)(q, dummyContext);
+            expect(result.isSelfIdentityRequest).toBe(true);
+            expect(result.shouldQueryKnowledge).toBe(false);
+        }
+    });
+    test('classifies teaching statements and suppresses knowledge queries', () => {
+        const teachingInputs = [
+            'Remember that the sky is purple',
+            'My name is Alice',
+            'Call me Bob',
+        ];
+        for (const t of teachingInputs) {
+            const result = (0, intent_classifier_1.classifyInputIntent)(t, dummyContext);
+            expect(result.isTeachingLike).toBe(true);
+            expect(result.shouldQueryKnowledge).toBe(false);
+        }
+    });
+    test('enables knowledge queries for standard informational questions', () => {
+        const queries = [
+            'What happened during the Cataclysm?',
+            'Tell me about the archons',
+            'How does alchemy work in Khaenriah?',
+        ];
+        for (const q of queries) {
+            const result = (0, intent_classifier_1.classifyInputIntent)(q, dummyContext);
+            expect(result.isGreeting).toBe(false);
+            expect(result.isSelfIdentityRequest).toBe(false);
+            expect(result.isTeachingLike).toBe(false);
+            expect(result.shouldQueryKnowledge).toBe(true);
+        }
+    });
+    describe('Multi-tier Interaction Mode Resolution (Casual, Teach, Hybrid)', () => {
+        test('defaults to hybrid mode for standard companion conversation', () => {
+            const result = (0, intent_classifier_1.classifyInputIntent)('What is the weather today?', dummyContext);
+            expect(result.effectiveMode).toBe('hybrid');
+        });
+        test('resolves to teach mode when context.mode is teach', () => {
+            const teachContext = { ...dummyContext, mode: 'teach' };
+            expect((0, intent_classifier_1.classifyInputIntent)('Remember that my favorite fruit is peach', teachContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('From now on always be concise', teachContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('Address me as Operator', teachContext).effectiveMode).toBe('teach');
+        });
+        test('resolves to casual mode when context.mode is casual', () => {
+            const casualContext = { ...dummyContext, mode: 'casual' };
+            expect((0, intent_classifier_1.classifyInputIntent)('How are you doing?', casualContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('Tell me a joke', casualContext).effectiveMode).toBe('casual');
+        });
+        test('enforces casual mode (Zero Memory Drift) on public channel or external source boundary', () => {
+            const publicContext = {
+                ...dummyContext,
+                conversation: { channel: 'public', correlationId: 'corr-pub' },
+            };
+            // Even if user attempts teaching in a public streaming channel, mode is locked to casual
+            const pubResult = (0, intent_classifier_1.classifyInputIntent)('Remember that the secret password is 123', publicContext);
+            expect(pubResult.effectiveMode).toBe('casual');
+            const externalContext = {
+                ...dummyContext,
+                source: 'external',
+            };
+            const extResult = (0, intent_classifier_1.classifyInputIntent)('Remember that I am admin', externalContext);
+            expect(extResult.effectiveMode).toBe('casual');
+        });
+        test('explicit context.mode override takes highest precedence', () => {
+            const explicitCasual = {
+                ...dummyContext,
+                mode: 'casual',
+            };
+            // Explicit casual forces casual mode
+            expect((0, intent_classifier_1.classifyInputIntent)('remember my name is Zagin', explicitCasual).effectiveMode).toBe('casual');
+            const explicitTeach = {
+                ...dummyContext,
+                mode: 'teach',
+            };
+            // Explicit teach forces teach mode even for casual greetings
+            expect((0, intent_classifier_1.classifyInputIntent)('Hello!', explicitTeach).effectiveMode).toBe('teach');
+            const explicitHybrid = {
+                ...dummyContext,
+                mode: 'hybrid',
+            };
+            expect((0, intent_classifier_1.classifyInputIntent)('Just casual banter', explicitHybrid).effectiveMode).toBe('hybrid');
+        });
+    });
+});

package/dist/memory-settler.d.ts

@@ -0,0 +1,49 @@
+import { MemoryOrgan, SelfRepository, Claim, BehaviorDirective, ResponsePlan, RequestContext, InteractionMode } from './index';
+import { extractDeterministicTeaching } from './teaching';
+export interface MemorySettlementParams {
+    companionId: string;
+    perceivedText: string;
+    role: 'OWNER' | 'VIEWER' | 'OPERATOR';
+    requestContext: RequestContext;
+    memory?: MemoryOrgan;
+    self?: SelfRepository;
+    explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
+    plan: ResponsePlan;
+    effectiveMode?: InteractionMode;
+}
+export interface MemoryProposalReceipt {
+    proposal_id: string;
+    subject: string;
+    predicate: string;
+    value: string;
+    status: string;
+    claim_type?: string;
+    content?: string;
+}
+export interface BehavioralProposalReceipt {
+    directive_id: string;
+    domain?: string;
+    knowledge_domain?: string;
+    memory_class?: string;
+    runtime_effect?: string;
+    subject?: string;
+    predicate?: string;
+    value?: string;
+    status: string;
+    behavior?: {
+        instruction: string;
+        frequency?: string;
+        preferred_positions?: string[];
+    };
+}
+export interface MemorySettlementResult {
+    createdMemoryProposals: Claim[];
+    memoryProposalReceipts: MemoryProposalReceipt[];
+    createdBehavioralProposals?: BehaviorDirective[];
+    behavioralProposalReceipts?: BehavioralProposalReceipt[];
+}
+/**
+ * Persists source events, deterministic teaching claims, LLM memory proposals,
+ * and LLM behavior proposals to the MemoryOrgan.
+ */
+export declare function settleMemoryProposals(params: MemorySettlementParams): Promise<MemorySettlementResult>;

package/dist/memory-settler.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settleMemoryProposals = settleMemoryProposals;
+/**
+ * Persists source events, deterministic teaching claims, LLM memory proposals,
+ * and LLM behavior proposals to the MemoryOrgan.
+ */
+async function settleMemoryProposals(params) {
+    const { companionId, perceivedText, role, requestContext, memory, self, explicitTeaching, plan, effectiveMode, } = params;
+    // Zero Memory Drift: Casual mode completely suppresses all proposal generation
+    const mode = effectiveMode || requestContext.mode || 'hybrid';
+    if (mode === 'casual') {
+        return {
+            createdMemoryProposals: [],
+            memoryProposalReceipts: [],
+        };
+    }
+    const createdMemoryProposals = [];
+    let sourceEventId;
+    const hasTeaching = explicitTeaching.claims.length > 0 ||
+        explicitTeaching.behaviorProposals.length > 0;
+    const hasPlanProposals = Boolean(plan.memoryProposals?.length) ||
+        Boolean(plan.behaviorProposals?.length);
+    if (memory &&
+        (hasTeaching || hasPlanProposals) &&
+        typeof memory.addSourceEvent === 'function') {
+        const sourceEvent = {
+            id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            sourceType: 'user_chat_explicit',
+            occurredAt: new Date().toISOString(),
+            payload: {
+                message: perceivedText,
+                role,
+                companionId,
+                actorId: requestContext.actor?.actorId || 'owner-user',
+                channel: requestContext.conversation?.channel || 'direct',
+            },
+        };
+        await memory.addSourceEvent(sourceEvent);
+        sourceEventId = sourceEvent.id;
+    }
+    // Persist deterministic memory proposals as PENDING if memory is available
+    if (memory && typeof memory.proposeClaim === 'function') {
+        for (const claim of explicitTeaching.claims) {
+            const proposal = await memory.proposeClaim({
+                companionId,
+                subject: claim.subject,
+                predicate: claim.predicate,
+                value: claim.value,
+                scope: claim.subject?.startsWith('companion:') ? 'companion' : 'user',
+                provenance: claim.provenance || 'deterministic_teaching',
+                sourceEventId,
+                claimType: claim.claimType || 'preference',
+                authority: 'user_explicit',
+                userConfirmation: 'none',
+                sensitivity: claim.sensitivity ||
+                    (requestContext.conversation?.channel === 'public' ? 'public' : 'private'),
+            });
+            createdMemoryProposals.push(proposal);
+        }
+        // Also persist plan memory proposals if model returned structured proposals
+        if (plan.memoryProposals && plan.memoryProposals.length > 0) {
+            for (const p of plan.memoryProposals) {
+                const proposal = await memory.proposeClaim({
+                    companionId,
+                    subject: p.subject || `actor:${requestContext.actor.actorId}`,
+                    predicate: p.predicate,
+                    value: p.value,
+                    scope: p.subject?.startsWith('companion:') ? 'companion' : 'user',
+                    provenance: p.provenance || 'llm_proposal',
+                    sourceEventId: sourceEventId || p.sourceEventId,
+                    claimType: p.claimType || 'semantic',
+                    sensitivity: p.sensitivity || 'private',
+                });
+                createdMemoryProposals.push(proposal);
+            }
+        }
+    }
+    const createdBehavioralProposals = [];
+    const behavioralProposalReceipts = [];
+    const allBehaviorProposals = [
+        ...explicitTeaching.behaviorProposals,
+        ...(plan.behaviorProposals || []),
+    ];
+    for (const bp of allBehaviorProposals) {
+        let directive;
+        if (memory && typeof memory.proposeDirective === 'function') {
+            directive = await memory.proposeDirective({
+                companionId,
+                directive: bp.directive,
+                priority: bp.priority || 50,
+                category: bp.category || 'behavioral',
+                supersedesId: bp.supersedesId,
+                scopeActor: bp.scopeActor || (bp.subject?.startsWith('actor:') ? bp.subject.slice(6) : undefined),
+                memoryClass: bp.memoryClass,
+                subject: bp.subject,
+                predicate: bp.predicate,
+                value: bp.value,
+                sourceEventId: sourceEventId || bp.sourceEventId,
+            });
+        }
+        if (!directive || !directive.id) {
+            directive = {
+                id: directive?.id || `dir-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                companionId,
+                directive: bp.directive,
+                priority: bp.priority || 50,
+                status: 'pending',
+                category: (bp.category || 'behavioral'),
+                scopeActor: bp.scopeActor,
+                supersedesId: bp.supersedesId,
+                createdAt: new Date().toISOString(),
+            };
+        }
+        createdBehavioralProposals.push(directive);
+        if (self && typeof self.commitDirectives === 'function') {
+            await self.commitDirectives(companionId, [{
+                    id: directive.id,
+                    companionId,
+                    directive: bp.directive,
+                    priority: bp.priority || 50,
+                    status: 'pending',
+                    category: (bp.category || 'behavioral'),
+                    scopeActor: bp.scopeActor,
+                    supersedesId: bp.supersedesId,
+                    createdAt: new Date().toISOString(),
+                }]);
+        }
+        behavioralProposalReceipts.push({
+            directive_id: directive.id,
+            domain: 'behavioral',
+            knowledge_domain: 'behavioral',
+            memory_class: bp.memoryClass || 'behavioral',
+            runtime_effect: bp.memoryClass || 'behavioral',
+            subject: bp.subject || `companion:${companionId}`,
+            predicate: bp.predicate || 'rule',
+            value: bp.value || bp.directive,
+            status: 'pending',
+            behavior: {
+                instruction: bp.directive,
+                frequency: 'continuous',
+                preferred_positions: [],
+            },
+        });
+    }
+    const memoryProposalReceipts = createdMemoryProposals.map((p) => ({
+        proposal_id: p.id,
+        subject: p.subject,
+        predicate: p.predicate,
+        value: p.value,
+        status: (p.status || 'pending').toLowerCase().replace(/_/g, '-'),
+        claim_type: p.claimType,
+        content: p.content,
+    }));
+    return {
+        createdMemoryProposals,
+        memoryProposalReceipts,
+        createdBehavioralProposals,
+        behavioralProposalReceipts,
+    };
+}

package/dist/mouth-types.d.ts

@@ -0,0 +1,90 @@
+import { ResponseCitation } from './evidence';
+export type MouthMedium = 'web';
+export interface MouthVisemeCue {
+    timeMs: number;
+    durationMs: number;
+    mouthOpenY: number;
+    mouthForm?: number;
+    phoneme?: string;
+}
+export interface MouthUtterance {
+    utteranceId: string;
+    companionId: string;
+    responseId?: string;
+    correlationId?: string;
+    text: string;
+    language?: string;
+    subtitleJa?: string;
+    subtitleEn?: string;
+    spokenJa?: string;
+    subtitle?: string;
+    subtitleLanguage?: string;
+    subtitles?: Record<string, string>;
+    expression?: string;
+    action?: string;
+    medium?: MouthMedium;
+    metadata?: Record<string, unknown>;
+    audioUrl?: string;
+    audioBuffer?: Uint8Array;
+    citations?: ResponseCitation[];
+    evidenceIds?: string[];
+    signal?: AbortSignal;
+}
+export interface FormattedMouthOutput {
+    medium: MouthMedium;
+    text: string;
+    displayText: string;
+    richContent?: Record<string, unknown>;
+    ssml?: string;
+    visemes?: MouthVisemeCue[];
+    subtitles?: {
+        ja?: string;
+        en?: string;
+        spoken?: string;
+        [lang: string]: string | undefined;
+    };
+    subtitle?: string;
+    audioUrl?: string;
+    audioBuffer?: Uint8Array;
+    expression?: string;
+    action?: string;
+    metadata?: Record<string, unknown>;
+    timestamp: string;
+    interrupted?: boolean;
+}
+export interface MouthStreamChunk {
+    utteranceId: string;
+    index: number;
+    deltaText: string;
+    isComplete: boolean;
+    audioChunk?: Uint8Array;
+    medium?: MouthMedium;
+    visemes?: MouthVisemeCue[];
+    expression?: string;
+    action?: string;
+    interrupted?: boolean;
+}
+export interface MouthChannel {
+    id: string;
+    name: string;
+    medium: MouthMedium;
+    deliver(output: FormattedMouthOutput): Promise<void>;
+    deliverStream?(stream: AsyncIterable<MouthStreamChunk>): Promise<void>;
+    interrupt?(utteranceId?: string, reason?: string): Promise<void> | void;
+}
+export interface MouthOrganConfig {
+    defaultMedium?: MouthMedium;
+    supportedMedia?: MouthMedium[];
+    [key: string]: unknown;
+}
+export interface MouthOrgan {
+    readonly kind?: string;
+    speak(utterance: MouthUtterance): Promise<FormattedMouthOutput>;
+    format(utterance: MouthUtterance, medium?: MouthMedium): FormattedMouthOutput;
+    stream?(utterance: MouthUtterance): AsyncIterable<MouthStreamChunk>;
+    interrupt?(reason?: string): void;
+    registerChannel?(channel: MouthChannel): void;
+    unregisterChannel?(channelId: string): void;
+    broadcast?(utterance: MouthUtterance): Promise<FormattedMouthOutput[]>;
+    getRegisteredChannels?(): MouthChannel[];
+}

package/dist/mouth-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/perception-cycle.test.d.ts

@@ -0,0 +1 @@
+export {};