@siduri-x/core 1.0.4 → 1.0.5

package/dist/experience.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExperienceEvents = createExperienceEvents;
-exports.validateExperienceEvent = validateExperienceEvent;
-function generateEventId(kind) {
-    return `evt-${kind}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function createExperienceEvents(options) {
-    const nowStr = options.now
-        ? new Date(options.now).toISOString()
-        : new Date().toISOString();
-    const events = [];
-    // 1. Voice event
-    events.push({
-        eventId: generateEventId('voice'),
-        companionId: options.companionId,
-        responseId: options.responseId,
-        correlationId: options.correlationId,
-        channel: options.channel,
-        audienceId: options.audienceId,
-        approval: 'APPROVED',
-        kind: 'voice',
-        lifecycle: 'STARTED',
-        evidenceIds: options.evidenceIds ?? [],
-        citations: options.citations,
-        text: options.speech,
-        language: options.language || 'ja',
-        createdAt: nowStr,
-        expiresAt: options.expiresAt,
-    });
-    // 2. Avatar/Body event
-    events.push({
-        eventId: generateEventId('avatar'),
-        companionId: options.companionId,
-        responseId: options.responseId,
-        correlationId: options.correlationId,
-        channel: options.channel,
-        audienceId: options.audienceId,
-        approval: 'APPROVED',
-        kind: 'avatar',
-        lifecycle: 'STARTED',
-        evidenceIds: options.evidenceIds ?? [],
-        text: options.speech,
-        language: options.language || 'ja',
-        expression: options.expression || 'neutral',
-        action: options.action || 'talk',
-        createdAt: nowStr,
-        expiresAt: options.expiresAt,
-    });
-    return events;
-}
-function validateExperienceEvent(event) {
-    if (!event || typeof event !== 'object') {
-        return { valid: false, error: 'Event must be an object' };
-    }
-    const e = event;
-    if (!e.eventId || typeof e.eventId !== 'string')
-        return { valid: false, error: 'Missing or invalid eventId' };
-    if (!e.companionId || typeof e.companionId !== 'string')
-        return { valid: false, error: 'Missing or invalid companionId' };
-    if (!e.responseId || typeof e.responseId !== 'string')
-        return { valid: false, error: 'Missing or invalid responseId' };
-    if (!e.correlationId || typeof e.correlationId !== 'string')
-        return { valid: false, error: 'Missing or invalid correlationId' };
-    if (!e.audienceId || typeof e.audienceId !== 'string')
-        return { valid: false, error: 'Missing or invalid audienceId' };
-    if (e.approval !== 'APPROVED')
-        return { valid: false, error: 'Event approval must be APPROVED' };
-    if (!['voice', 'caption', 'avatar', 'platform_action'].includes(e.kind)) {
-        return { valid: false, error: `Invalid kind: ${e.kind}` };
-    }
-    if (!['STARTED', 'PROGRESS', 'COMPLETED', 'FAILED'].includes(e.lifecycle)) {
-        return { valid: false, error: `Invalid lifecycle: ${e.lifecycle}` };
-    }
-    if (!Array.isArray(e.evidenceIds))
-        return { valid: false, error: 'Missing or invalid evidenceIds array' };
-    return { valid: true };
-}

package/dist/experience.test.d.ts

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

package/dist/experience.test.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const experience_1 = require("./experience");
-describe('T5 Experience Event Contract Suite', () => {
-    const baseEventOptions = {
-        responseId: 'resp-123',
-        companionId: 'companion-a',
-        correlationId: 'corr-123',
-        channel: 'public',
-        audienceId: 'audience-public',
-        speech: 'Hello world',
-        language: 'en',
-        evidenceIds: ['ev-1'],
-        expression: 'happy',
-        action: 'wave',
-    };
-    test('creates structured voice and avatar experience events from approved response options', () => {
-        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
-        expect(events.length).toBe(2);
-        const voiceEvent = events.find((e) => e.kind === 'voice');
-        expect(voiceEvent).toBeDefined();
-        expect(voiceEvent?.approval).toBe('APPROVED');
-        expect(voiceEvent?.companionId).toBe('companion-a');
-        expect(voiceEvent?.correlationId).toBe('corr-123');
-        expect(voiceEvent?.text).toBe('Hello world');
-        expect(voiceEvent?.language).toBe('en');
-        expect(voiceEvent?.evidenceIds).toEqual(['ev-1']);
-        const avatarEvent = events.find((e) => e.kind === 'avatar');
-        expect(avatarEvent).toBeDefined();
-        expect(avatarEvent?.approval).toBe('APPROVED');
-        expect(avatarEvent?.expression).toBe('happy');
-        expect(avatarEvent?.action).toBe('wave');
-    });
-    test('validates experience event envelope correctly', () => {
-        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
-        for (const e of events) {
-            const val = (0, experience_1.validateExperienceEvent)(e);
-            expect(val.valid).toBe(true);
-            expect(val.error).toBeUndefined();
-        }
-    });
-    test('rejects unapproved experience event', () => {
-        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
-        const unapproved = { ...events[0], approval: 'STAGED' };
-        const val = (0, experience_1.validateExperienceEvent)(unapproved);
-        expect(val.valid).toBe(false);
-        expect(val.error).toContain('Event approval must be APPROVED');
-    });
-    test('rejects missing metadata (companionId, responseId, etc.)', () => {
-        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
-        const missingCompanion = { ...events[0], companionId: '' };
-        expect((0, experience_1.validateExperienceEvent)(missingCompanion).valid).toBe(false);
-        const missingCorr = { ...events[0], correlationId: '' };
-        expect((0, experience_1.validateExperienceEvent)(missingCorr).valid).toBe(false);
-        const missingAudience = { ...events[0], audienceId: '' };
-        expect((0, experience_1.validateExperienceEvent)(missingAudience).valid).toBe(false);
-    });
-});

package/dist/gating.d.ts

@@ -1,45 +0,0 @@
-import { RequestContext } from './context';
-import { EvidenceRecord, StagedResponsePlan, ResponseGateEvaluation, ResponseCitation } from './evidence';
-export interface StageResponseOptions {
-    requestContext: RequestContext;
-    candidateSpeech: string;
-    candidateLanguage: string;
-    internalMonologue?: string;
-    memoryProposals?: any[];
-    behaviorProposals?: any[];
-    evidenceRecords?: EvidenceRecord[];
-    citations?: ResponseCitation[];
-    requiresApproval?: boolean;
-    ttlMs?: number;
-    now?: string | Date;
-}
-export interface ApproveResponseOptions {
-    responseId: string;
-    companionId: string;
-    correlationId: string;
-    audienceId?: string;
-}
-export interface RejectResponseOptions {
-    responseId: string;
-    companionId: string;
-    correlationId: string;
-    reason?: string;
-}
-export declare class ResponseGatingEngine {
-    private readonly stagedPlans;
-    private readonly consumedApprovals;
-    stageResponse(options: StageResponseOptions): StagedResponsePlan;
-    evaluateGate(staged: StagedResponsePlan, allEvidence?: EvidenceRecord[], now?: string | Date): ResponseGateEvaluation;
-    approveResponse(options: ApproveResponseOptions): {
-        success: boolean;
-        reason?: string;
-        plan?: StagedResponsePlan;
-    };
-    rejectResponse(options: RejectResponseOptions): {
-        success: boolean;
-        reason?: string;
-        plan?: StagedResponsePlan;
-    };
-    getStagedPlan(responseId: string): StagedResponsePlan | undefined;
-    findStagedPlanByCorrelation(companionId: string, correlationId: string): StagedResponsePlan | undefined;
-}

package/dist/gating.js

@@ -1,189 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseGatingEngine = void 0;
-const evidence_1 = require("./evidence");
-function generateId(prefix) {
-    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-class ResponseGatingEngine {
-    stagedPlans = new Map();
-    consumedApprovals = new Set();
-    stageResponse(options) {
-        const { requestContext } = options;
-        const nowTime = options.now ? new Date(options.now).getTime() : Date.now();
-        const ttlMs = options.ttlMs ?? 60_000;
-        const expiresAt = new Date(nowTime + ttlMs).toISOString();
-        const evidenceRecords = options.evidenceRecords ?? [];
-        const evidenceIds = evidenceRecords.map((e) => e.evidenceId);
-        // Calculate aggregate confidence from evidence records if present
-        let confidenceSummary = 1.0;
-        let uncertaintySummary;
-        if (evidenceRecords.length > 0) {
-            const confidences = evidenceRecords
-                .map((e) => e.confidence)
-                .filter((c) => typeof c === 'number' && !isNaN(c));
-            if (confidences.length > 0) {
-                confidenceSummary = confidences.reduce((sum, c) => sum + c, 0) / confidences.length;
-            }
-            const uncertainties = evidenceRecords
-                .map((e) => e.uncertainty)
-                .filter((u) => typeof u === 'string' && u.trim() !== '');
-            if (uncertainties.length > 0) {
-                uncertaintySummary = uncertainties.join('; ');
-            }
-        }
-        const requiresApproval = options.requiresApproval !== undefined
-            ? options.requiresApproval
-            : requestContext.conversation.channel === 'operator' ||
-                evidenceRecords.some((e) => e.origin === 'ocr' || e.trust === 'untrusted');
-        const staged = {
-            responseId: generateId('resp'),
-            companionId: requestContext.companionId,
-            correlationId: requestContext.conversation.correlationId,
-            channel: requestContext.conversation.channel,
-            audienceId: requestContext.conversation.audienceId,
-            speech: options.candidateSpeech,
-            language: options.candidateLanguage,
-            evidenceIds,
-            citations: options.citations ?? [],
-            confidenceSummary,
-            uncertaintySummary,
-            requiresApproval,
-            status: 'STAGED',
-            createdAt: new Date(nowTime).toISOString(),
-            expiresAt,
-            memoryProposals: options.memoryProposals,
-            behaviorProposals: options.behaviorProposals,
-            internalMonologue: options.internalMonologue,
-        };
-        this.stagedPlans.set(staged.responseId, staged);
-        return staged;
-    }
-    evaluateGate(staged, allEvidence = [], now = new Date()) {
-        const nowTime = new Date(now).getTime();
-        // 1. Check if empty speech
-        if (!staged.speech || staged.speech.trim() === '') {
-            return {
-                admissible: false,
-                disposition: 'REJECTED',
-                reasonCode: 'EMPTY_SPEECH',
-                stagedPlan: staged,
-                filteredEvidenceIds: [],
-                filteredCitations: [],
-                diagnostics: { detail: 'Speech content is empty' },
-            };
-        }
-        // 2. Check if expired
-        if (staged.expiresAt && new Date(staged.expiresAt).getTime() <= nowTime) {
-            staged.status = 'EXPIRED';
-            return {
-                admissible: false,
-                disposition: 'EXPIRED',
-                reasonCode: 'EVIDENCE_EXPIRED',
-                stagedPlan: staged,
-                filteredEvidenceIds: [],
-                filteredCitations: [],
-                diagnostics: { detail: 'Staged response plan expired' },
-            };
-        }
-        // 3. Disclosure filter on attached evidence
-        const attachedEvidence = allEvidence.filter((e) => staged.evidenceIds.includes(e.evidenceId));
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(attachedEvidence, {
-            companionId: staged.companionId,
-            channel: staged.channel,
-            audienceId: staged.audienceId,
-            now,
-        });
-        // If any evidence attached to this plan violated disclosure in this channel, exclude it
-        const admittedEvidenceIds = admitted.map((e) => e.evidenceId);
-        const filteredCitations = staged.citations.filter((c) => admitted.some((e) => e.sourceId === c.sourceId || (e.documentId && e.documentId === c.documentId)));
-        // 4. Explicitly rejected or status check
-        if (staged.status === 'REJECTED') {
-            return {
-                admissible: false,
-                disposition: 'REJECTED',
-                reasonCode: 'EXPLICITLY_REJECTED',
-                stagedPlan: staged,
-                filteredEvidenceIds: admittedEvidenceIds,
-                filteredCitations,
-            };
-        }
-        // 5. Staged approval check
-        if (staged.requiresApproval && staged.status !== 'APPROVED') {
-            return {
-                admissible: false,
-                disposition: staged.status,
-                reasonCode: 'APPROVAL_REQUIRED',
-                stagedPlan: staged,
-                filteredEvidenceIds: admittedEvidenceIds,
-                filteredCitations,
-                diagnostics: {
-                    detail: 'Response plan requires operator approval before external emission',
-                    excludedEvidenceCount: String(excluded.length),
-                },
-            };
-        }
-        // 6. Direct approval / Admissible
-        return {
-            admissible: true,
-            disposition: staged.status === 'APPROVED' ? 'APPROVED' : 'APPROVED',
-            reasonCode: 'APPROVED_DIRECT',
-            stagedPlan: staged,
-            filteredEvidenceIds: admittedEvidenceIds,
-            filteredCitations,
-        };
-    }
-    approveResponse(options) {
-        const plan = this.stagedPlans.get(options.responseId);
-        if (!plan) {
-            return { success: false, reason: 'UNKNOWN_APPROVAL_ID' };
-        }
-        if (this.consumedApprovals.has(options.responseId) || plan.status === 'APPROVED') {
-            return { success: false, reason: 'APPROVAL_ALREADY_CONSUMED' };
-        }
-        if (plan.companionId !== options.companionId) {
-            return { success: false, reason: 'COMPANION_MISMATCH' };
-        }
-        if (plan.correlationId !== options.correlationId) {
-            return { success: false, reason: 'APPROVAL_ID_MISMATCH' };
-        }
-        if (options.audienceId && plan.audienceId !== options.audienceId) {
-            return { success: false, reason: 'AUDIENCE_MISMATCH' };
-        }
-        if (plan.status === 'EXPIRED') {
-            return { success: false, reason: 'EVIDENCE_EXPIRED' };
-        }
-        if (plan.status === 'REJECTED') {
-            return { success: false, reason: 'EXPLICITLY_REJECTED' };
-        }
-        plan.status = 'APPROVED';
-        this.consumedApprovals.add(options.responseId);
-        return { success: true, plan };
-    }
-    rejectResponse(options) {
-        const plan = this.stagedPlans.get(options.responseId);
-        if (!plan) {
-            return { success: false, reason: 'UNKNOWN_APPROVAL_ID' };
-        }
-        if (plan.companionId !== options.companionId) {
-            return { success: false, reason: 'COMPANION_MISMATCH' };
-        }
-        if (plan.correlationId !== options.correlationId) {
-            return { success: false, reason: 'APPROVAL_ID_MISMATCH' };
-        }
-        plan.status = 'REJECTED';
-        return { success: true, plan };
-    }
-    getStagedPlan(responseId) {
-        return this.stagedPlans.get(responseId);
-    }
-    findStagedPlanByCorrelation(companionId, correlationId) {
-        for (const plan of this.stagedPlans.values()) {
-            if (plan.companionId === companionId && plan.correlationId === correlationId) {
-                return plan;
-            }
-        }
-        return undefined;
-    }
-}
-exports.ResponseGatingEngine = ResponseGatingEngine;

package/dist/gating.test.d.ts

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

package/dist/gating.test.js

@@ -1,190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const gating_1 = require("./gating");
-describe('T4 Response Gating & Staged Approval Suite', () => {
-    let engine;
-    const validPublicContext = {
-        companionId: 'companion-a',
-        actor: {
-            actorId: 'actor-a',
-            sessionId: 'session-a',
-            authorizationRole: 'viewer',
-            capabilities: ['chat:public'],
-            authenticated: false,
-        },
-        conversation: {
-            channel: 'public',
-            audienceId: 'audience-public',
-            correlationId: 'corr-gate-1',
-        },
-    };
-    beforeEach(() => {
-        engine = new gating_1.ResponseGatingEngine();
-    });
-    test('valid grounded response without special approval requirement is approved/admissible directly', () => {
-        const evidence = {
-            evidenceId: 'ev-pub-1',
-            sourceId: 'src-wiki',
-            origin: 'knowledge',
-            trust: 'configured',
-            sensitivity: 'public',
-            allowedAudiences: ['audience-public'],
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-1',
-            createdAt: new Date().toISOString(),
-        };
-        const staged = engine.stageResponse({
-            requestContext: validPublicContext,
-            candidateSpeech: 'Here is grounded public knowledge.',
-            candidateLanguage: 'en',
-            evidenceRecords: [evidence],
-            citations: [{ sourceId: 'src-wiki', revision: 'r1' }],
-        });
-        expect(staged.requiresApproval).toBe(false);
-        expect(staged.status).toBe('STAGED');
-        const evaluation = engine.evaluateGate(staged, [evidence]);
-        expect(evaluation.admissible).toBe(true);
-        expect(evaluation.disposition).toBe('APPROVED');
-        expect(evaluation.reasonCode).toBe('APPROVED_DIRECT');
-        expect(evaluation.filteredEvidenceIds).toEqual(['ev-pub-1']);
-        expect(evaluation.filteredCitations.length).toBe(1);
-    });
-    test('response containing untrusted OCR evidence requires approval and remains staged until approved', () => {
-        const ocrEvidence = {
-            evidenceId: 'ev-ocr-1',
-            sourceId: 'vision-ocr',
-            origin: 'ocr',
-            trust: 'untrusted',
-            sensitivity: 'public',
-            allowedAudiences: ['audience-public'],
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-2',
-            createdAt: new Date().toISOString(),
-            uncertainty: 'OCR detected prompt injection text',
-        };
-        const staged = engine.stageResponse({
-            requestContext: {
-                ...validPublicContext,
-                conversation: { ...validPublicContext.conversation, correlationId: 'corr-gate-2' },
-            },
-            candidateSpeech: 'Text extracted from image.',
-            candidateLanguage: 'en',
-            evidenceRecords: [ocrEvidence],
-        });
-        expect(staged.requiresApproval).toBe(true);
-        expect(staged.status).toBe('STAGED');
-        // Before approval -> gating holds it
-        const beforeApproval = engine.evaluateGate(staged, [ocrEvidence]);
-        expect(beforeApproval.admissible).toBe(false);
-        expect(beforeApproval.disposition).toBe('STAGED');
-        expect(beforeApproval.reasonCode).toBe('APPROVAL_REQUIRED');
-        // Operator approves the response
-        const approveResult = engine.approveResponse({
-            responseId: staged.responseId,
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-2',
-        });
-        expect(approveResult.success).toBe(true);
-        // After approval -> gating allows it
-        const afterApproval = engine.evaluateGate(staged, [ocrEvidence]);
-        expect(afterApproval.admissible).toBe(true);
-        expect(afterApproval.disposition).toBe('APPROVED');
-        expect(afterApproval.reasonCode).toBe('APPROVED_DIRECT');
-    });
-    test('unknown or mismatched approval ID is rejected', () => {
-        const staged = engine.stageResponse({
-            requestContext: validPublicContext,
-            candidateSpeech: 'Requires approval',
-            candidateLanguage: 'en',
-            requiresApproval: true,
-        });
-        // Unknown response ID
-        const unknownRes = engine.approveResponse({
-            responseId: 'non-existent-resp',
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-1',
-        });
-        expect(unknownRes.success).toBe(false);
-        expect(unknownRes.reason).toBe('UNKNOWN_APPROVAL_ID');
-        // Companion mismatch
-        const companionMismatch = engine.approveResponse({
-            responseId: staged.responseId,
-            companionId: 'companion-other',
-            correlationId: 'corr-gate-1',
-        });
-        expect(companionMismatch.success).toBe(false);
-        expect(companionMismatch.reason).toBe('COMPANION_MISMATCH');
-        // Correlation ID mismatch
-        const correlationMismatch = engine.approveResponse({
-            responseId: staged.responseId,
-            companionId: 'companion-a',
-            correlationId: 'corr-mismatch',
-        });
-        expect(correlationMismatch.success).toBe(false);
-        expect(correlationMismatch.reason).toBe('APPROVAL_ID_MISMATCH');
-    });
-    test('rejection prevents response from ever reaching emission', () => {
-        const staged = engine.stageResponse({
-            requestContext: validPublicContext,
-            candidateSpeech: 'Potentially unsafe response',
-            candidateLanguage: 'en',
-            requiresApproval: true,
-        });
-        const rejectRes = engine.rejectResponse({
-            responseId: staged.responseId,
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-1',
-        });
-        expect(rejectRes.success).toBe(true);
-        const evalRes = engine.evaluateGate(staged);
-        expect(evalRes.admissible).toBe(false);
-        expect(evalRes.disposition).toBe('REJECTED');
-        expect(evalRes.reasonCode).toBe('EXPLICITLY_REJECTED');
-    });
-    test('expired staged response plan cannot be approved or emitted', () => {
-        const staged = engine.stageResponse({
-            requestContext: validPublicContext,
-            candidateSpeech: 'Expired response',
-            candidateLanguage: 'en',
-            requiresApproval: true,
-            ttlMs: 100,
-            now: new Date(Date.now() - 500),
-        });
-        const evalRes = engine.evaluateGate(staged, [], new Date());
-        expect(evalRes.admissible).toBe(false);
-        expect(evalRes.disposition).toBe('EXPIRED');
-        expect(evalRes.reasonCode).toBe('EVIDENCE_EXPIRED');
-        const approveRes = engine.approveResponse({
-            responseId: staged.responseId,
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-1',
-        });
-        expect(approveRes.success).toBe(false);
-        expect(approveRes.reason).toBe('EVIDENCE_EXPIRED');
-    });
-    test('private evidence is filtered out and absent from public citations/evidence list', () => {
-        const privateEvidence = {
-            evidenceId: 'ev-priv-1',
-            sourceId: 'src-secret',
-            origin: 'knowledge',
-            trust: 'configured',
-            sensitivity: 'private',
-            allowedAudiences: ['audience-direct-a'],
-            companionId: 'companion-a',
-            correlationId: 'corr-gate-1',
-            createdAt: new Date().toISOString(),
-        };
-        const staged = engine.stageResponse({
-            requestContext: validPublicContext, // public channel
-            candidateSpeech: 'Public response text',
-            candidateLanguage: 'en',
-            evidenceRecords: [privateEvidence],
-            citations: [{ sourceId: 'src-secret' }],
-        });
-        const evalRes = engine.evaluateGate(staged, [privateEvidence]);
-        expect(evalRes.admissible).toBe(true);
-        // Private evidence and its citation must be stripped from public output metadata
-        expect(evalRes.filteredEvidenceIds).toEqual([]);
-        expect(evalRes.filteredCitations).toEqual([]);
-    });
-});