@siduri-x/core 1.0.4 → 1.0.7

package/dist/proposals.d.ts

@@ -0,0 +1,30 @@
+export type ClaimType = 'semantic' | 'preference' | 'episodic' | 'relationship';
+export type ClaimAuthority = 'user_explicit' | 'user_correction' | 'import' | 'repeated_dialogue' | 'inference' | 'observation';
+export type ClaimStatus = 'PENDING' | 'APPROVED' | 'REJECTED' | 'SESSION_ONLY' | 'EXPIRED' | 'SUPERSEDED' | 'REVOKED';
+export interface SourceEvent {
+    id: string;
+    sourceType: string;
+    occurredAt: string;
+    payload: Record<string, unknown>;
+    schemaVersion?: number;
+}
+export interface MemoryProposal {
+    subject: string;
+    predicate: string;
+    value: string;
+    content?: string;
+    provenance?: string;
+    claimType?: ClaimType;
+    sensitivity?: string;
+    allowedAudiences?: string[];
+    sourceEventId?: string;
+}
+export interface BehaviorProposal {
+    directive: string;
+    priority: number;
+    subject?: string;
+    predicate?: string;
+    value?: string;
+    memoryClass?: 'identity' | 'relationship' | 'behavioral' | 'semantic' | 'episodic';
+    sourceEventId?: string;
+}

package/dist/proposals.js

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

package/dist/response-envelope.d.ts

@@ -0,0 +1,25 @@
+import { StagedResponsePlan, ResponseGateEvaluation, Claim, ResponseCitation, ExperienceEvent, ActionExecutionResult } from './index';
+import { MemoryProposalReceipt } from './memory-settler';
+import { FormattedMouthOutput } from './mouth-types';
+export interface AssembleResponseEnvelopeParams {
+    stagedPlan: StagedResponsePlan;
+    speech: string;
+    language?: string;
+    speechId?: string;
+    createdMemoryProposals: Claim[];
+    memoryProposalReceipts: MemoryProposalReceipt[];
+    actionResults: ActionExecutionResult[];
+    filteredEvidenceIds?: string[];
+    filteredCitations?: ResponseCitation[];
+    subsystemDiagnostics: Record<string, string>;
+    experienceEvents: ExperienceEvent[];
+    mouthDelivery?: FormattedMouthOutput;
+}
+/**
+ * Creates the standardized rejection envelope for responses that fail gate evaluation.
+ */
+export declare function createGateRejectionEnvelope(stagedPlan: StagedResponsePlan, gateEval: ResponseGateEvaluation): any;
+/**
+ * Assembles the standardized response structure for approved companion responses.
+ */
+export declare function assembleResponseEnvelope(params: AssembleResponseEnvelopeParams): any;

package/dist/response-envelope.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGateRejectionEnvelope = createGateRejectionEnvelope;
+exports.assembleResponseEnvelope = assembleResponseEnvelope;
+/**
+ * Creates the standardized rejection envelope for responses that fail gate evaluation.
+ */
+function createGateRejectionEnvelope(stagedPlan, gateEval) {
+    return {
+        status: gateEval.disposition,
+        reasonCode: gateEval.reasonCode,
+        response_id: stagedPlan.responseId,
+        correlation_id: stagedPlan.correlationId,
+        response: {
+            subtitle_ja: undefined,
+            subtitle_en: undefined,
+        },
+        metadata: {
+            requires_approval: stagedPlan.requiresApproval,
+            staged: true,
+            confidence: stagedPlan.confidenceSummary,
+            uncertainty: stagedPlan.uncertaintySummary,
+            proposals: [],
+            memory_proposals: [],
+        },
+    };
+}
+/**
+ * Assembles the standardized response structure for approved companion responses.
+ */
+function assembleResponseEnvelope(params) {
+    const { stagedPlan, speech, language, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, } = params;
+    return {
+        status: 'APPROVED',
+        response_id: stagedPlan.responseId,
+        correlation_id: stagedPlan.correlationId,
+        response: {
+            speech_id: speechId,
+            audio_url: mouthDelivery?.audioUrl ?? (speechId ? `/voice/stream?id=${speechId}` : undefined),
+            subtitle_ja: mouthDelivery?.subtitles?.ja ?? speech,
+            subtitle_en: mouthDelivery?.subtitles?.en ?? speech,
+        },
+        delivery: mouthDelivery,
+        metadata: {
+            language,
+            proposals: createdMemoryProposals,
+            memory_proposals: memoryProposalReceipts,
+            action_results: actionResults,
+            evidence_ids: filteredEvidenceIds,
+            citations: filteredCitations,
+            subsystem_diagnostics: Object.keys(subsystemDiagnostics).length > 0
+                ? subsystemDiagnostics
+                : undefined,
+            events: experienceEvents.map((e) => ({
+                event_id: e.eventId,
+                kind: e.kind,
+                lifecycle: e.lifecycle,
+                approval: e.approval,
+                expression: e.expression,
+                action: e.action,
+            })),
+        },
+    };
+}

package/dist/runtime-facades.test.d.ts

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

package/dist/runtime-facades.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("./runtime");
+describe('SiduriRuntime Facade Methods & Delegation', () => {
+    test('delegates vision and observation methods to configured organs', async () => {
+        const mockVision = {
+            analyze: jest.fn().mockResolvedValue('an ancient artifact'),
+        };
+        const mockObservation = {
+            ingest: jest.fn().mockResolvedValue({ duplicate: false }),
+            current: jest.fn().mockReturnValue([{ observationId: 'obs-1' }]),
+            clearExpired: jest.fn().mockReturnValue(1),
+        };
+        const runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test' }, {
+            vision: mockVision,
+            observation: mockObservation,
+        });
+        const visionResult = await runtime.analyzeVision('http://example.com/img.png', 'describe');
+        expect(visionResult).toBe('an ancient artifact');
+        expect(mockVision.analyze).toHaveBeenCalledWith('http://example.com/img.png', 'describe');
+        const frame = new Uint8Array([1, 2, 3]);
+        const obsResult = await runtime.ingestObservation(frame, 'camera-1', 'provider-x');
+        expect(obsResult.duplicate).toBe(false);
+        expect(mockObservation.ingest).toHaveBeenCalledWith(frame, 'camera-1', 'provider-x');
+        const cur = runtime.getCurrentObservations();
+        expect(cur).toEqual([{ observationId: 'obs-1' }]);
+        const cleared = runtime.clearExpiredObservations();
+        expect(cleared).toBe(1);
+    });
+    test('delegates memory operations cleanly through facade methods', async () => {
+        const mockMemory = {
+            initialize: jest.fn().mockResolvedValue(undefined),
+            getClaims: jest.fn().mockResolvedValue([{ id: 'claim-1' }]),
+            getPendingClaims: jest.fn().mockResolvedValue([{ id: 'claim-pending-1' }]),
+            getDirectives: jest.fn().mockResolvedValue([{ id: 'dir-1' }]),
+            approveClaim: jest.fn().mockResolvedValue(undefined),
+            rejectClaim: jest.fn().mockResolvedValue(undefined),
+            updateClaim: jest.fn().mockResolvedValue({ id: 'claim-1', value: 'updated' }),
+            approveDirective: jest.fn().mockResolvedValue(undefined),
+            rejectDirective: jest.fn().mockResolvedValue(undefined),
+            revokeDirective: jest.fn().mockResolvedValue(undefined),
+            disableDirective: jest.fn().mockResolvedValue(undefined),
+            resetMemory: jest.fn().mockResolvedValue(undefined),
+        };
+        const runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test' }, {
+            memory: mockMemory,
+        });
+        expect(await runtime.getClaims(10)).toEqual([{ id: 'claim-1' }]);
+        expect(mockMemory.getClaims).toHaveBeenCalledWith(10);
+        expect(await runtime.getPendingClaims()).toEqual([{ id: 'claim-pending-1' }]);
+        expect(await runtime.getDirectives()).toEqual([{ id: 'dir-1' }]);
+        await runtime.approveClaim('c-1');
+        expect(mockMemory.approveClaim).toHaveBeenCalledWith('c-1');
+        await runtime.rejectClaim('c-2');
+        expect(mockMemory.rejectClaim).toHaveBeenCalledWith('c-2');
+        await runtime.updateClaim('c-1', { value: 'new' });
+        expect(mockMemory.updateClaim).toHaveBeenCalledWith('c-1', { value: 'new' });
+        await runtime.approveDirective('d-1');
+        expect(mockMemory.approveDirective).toHaveBeenCalledWith('d-1');
+        await runtime.rejectDirective('d-2');
+        expect(mockMemory.rejectDirective).toHaveBeenCalledWith('d-2');
+        await runtime.revokeDirective('d-3');
+        expect(mockMemory.revokeDirective).toHaveBeenCalledWith('d-3');
+        await runtime.disableDirective('d-4');
+        expect(mockMemory.disableDirective).toHaveBeenCalledWith('d-4');
+        await runtime.resetMemory();
+        expect(mockMemory.resetMemory).toHaveBeenCalled();
+    });
+});

package/dist/runtime.d.ts

@@ -1,18 +1,19 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, Message, ActionPolicyEngine, RequestContext, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter } from './index';
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
 export interface SiduriRuntimeConfig {
     name: string;
-    brain?: any;
-    voice?: any;
-    memory?: any;
-    knowledge?: any;
-    behavior?: any;
-    body?: any;
-    vision?: any;
-    hands?: any;
-    ear?: any;
-    observation?: any;
-    actionPolicy?: any;
-    [key: string]: any;
+    brain?: OrganConfig | Record<string, unknown>;
+    voice?: OrganConfig | Record<string, unknown>;
+    memory?: OrganConfig | Record<string, unknown>;
+    knowledge?: OrganConfig | Record<string, unknown>;
+    behavior?: OrganConfig | Record<string, unknown>;
+    body?: OrganConfig | Record<string, unknown>;
+    vision?: OrganConfig | Record<string, unknown>;
+    hands?: OrganConfig | Record<string, unknown>;
+    ear?: OrganConfig | Record<string, unknown>;
+    observation?: OrganConfig | Record<string, unknown>;
+    mouth?: OrganConfig | Record<string, unknown>;
+    actionPolicy?: Record<string, unknown>;
+    [key: string]: unknown;
 }
 export interface RuntimeOrgans {
     brain?: BrainOrgan;
@@ -25,8 +26,25 @@ export interface RuntimeOrgans {
     hands?: HandsOrgan;
     ear?: EarOrgan;
     observation?: ObservationOrgan;
+    mouth?: MouthOrgan;
     actionPolicy?: ActionPolicyEngine;
 }
+export interface CompanionPerception {
+    source: string;
+    text?: string;
+    audioBuffer?: Uint8Array;
+    roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string;
+    context?: RequestContext;
+    history?: Message[];
+    medium?: MouthMedium;
+    metadata?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+/**
+ * SiduriRuntime coordinates companion lifecycle, sensory perception,
+ * context retrieval, cognition planning, safety gating, action execution,
+ * and experience emission across decoupled organs.
+ */
 export declare class SiduriRuntime {
     id: string;
     config: SiduriRuntimeConfig;
@@ -40,11 +58,57 @@ export declare class SiduriRuntime {
     hands?: HandsOrgan;
     ear?: EarOrgan;
     observation?: ObservationOrgan;
+    mouth?: MouthOrgan;
     gating: ResponseGatingEngine;
     actionPolicy: ActionPolicyEngine;
     dispatcher: ExperienceDispatcher;
-    private conversationHistory;
+    private readonly sessionHistory;
+    get conversationHistory(): Message[];
+    set conversationHistory(messages: Message[]);
     constructor(id: string, config: SiduriRuntimeConfig, organs?: RuntimeOrgans);
     initialize(): Promise<void>;
-    handleUserMessage(message: string, roleOrContext: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext, history?: Message[]): Promise<any>;
+    getSessionHistory(sessionKey: string): Message[];
+    clearHistory(sessionKey?: string): void;
+    analyzeVision(imageUrl: string, prompt: string): Promise<string>;
+    ingestObservation(frame: Uint8Array, sourceName: string, providerId?: string): Promise<ObservationResult>;
+    getCurrentObservations(now?: Date): Observation[];
+    clearExpiredObservations(now?: Date): number;
+    getClaims(limit?: number): Promise<Claim[]>;
+    getPendingClaims(limit?: number): Promise<Claim[]>;
+    getDirectives(): Promise<BehaviorDirective[]>;
+    approveClaim(id: string): Promise<void>;
+    rejectClaim(id: string): Promise<void>;
+    updateClaim(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
+    approveDirective(id: string): Promise<void>;
+    rejectDirective(id: string): Promise<void>;
+    revokeDirective(id: string): Promise<void>;
+    disableDirective(id: string): Promise<void>;
+    resetMemory(): Promise<void>;
+    stageResponse(options: StageResponseOptions): StagedResponsePlan;
+    evaluateGate(plan: StagedResponsePlan, evidenceRecords?: EvidenceRecord[]): 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;
+    /**
+     * Processes an incoming perception (sensory audio, text, platform event, or observation alert)
+     * through the perception -> retrieval -> cognition -> gating -> action -> experience cycle.
+     */
+    processPerception(perception: CompanionPerception): Promise<any>;
+    speakMouth(utterance: MouthUtterance): Promise<FormattedMouthOutput | undefined>;
+    formatMouth(utterance: MouthUtterance, medium?: MouthMedium): FormattedMouthOutput | undefined;
+    registerMouthChannel(channel: MouthChannel): void;
+    unregisterMouthChannel(channelId: string): void;
+    broadcastMouth(utterance: MouthUtterance): Promise<FormattedMouthOutput[]>;
+    interruptMouth(reason?: string): void;
+    streamMouth(utterance: MouthUtterance): AsyncIterable<MouthStreamChunk>;
+    handleUserMessage(message: string, roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string, history?: Message[], medium?: MouthMedium, signal?: AbortSignal): Promise<any>;
 }