@siduri-x/api 1.0.4 → 2.0.1

package/dist/cors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowedOrigins = getAllowedOrigins;
+exports.createCorsOptions = createCorsOptions;
+function getAllowedOrigins() {
+    const allowed = new Set([
+        'http://localhost:3000',
+        'http://127.0.0.1:3000',
+        'http://localhost:3001',
+        'http://127.0.0.1:3001',
+    ]);
+    if (process.env.PORT) {
+        allowed.add(`http://localhost:${process.env.PORT}`);
+        allowed.add(`http://127.0.0.1:${process.env.PORT}`);
+    }
+    const envOrigins = process.env.ALLOWED_ORIGINS;
+    if (envOrigins) {
+        for (const origin of envOrigins.split(',')) {
+            const trimmed = origin.trim();
+            if (trimmed) {
+                allowed.add(trimmed);
+            }
+        }
+    }
+    return allowed;
+}
+function createCorsOptions() {
+    return {
+        origin: (origin, callback) => {
+            // Allow non-browser requests with no origin header (e.g., native tools, curl)
+            if (!origin) {
+                return callback(null, true);
+            }
+            const allowedOrigins = getAllowedOrigins();
+            if (allowedOrigins.has(origin)) {
+                return callback(null, true);
+            }
+            return callback(null, false);
+        },
+        credentials: true,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Express } from 'express';
+import { createApp, AppInstance } from './app';
+export { createApp, AppInstance };
+export * from './context-mapper';
+export declare const app: Express;
+export default app;

package/dist/index.js

@@ -18,6 +18,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = exports.createApp = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const app_1 = require("./app");
@@ -26,9 +28,9 @@ const runtime_1 = require("./runtime");
 const brain_1 = require("@siduri-x/brain");
 const memory_1 = require("@siduri-x/memory");
 const voice_1 = require("@siduri-x/voice");
-const knowledge_1 = require("@siduri-x/knowledge");
+const eknowledge_1 = require("@siduri-x/eknowledge");
 const vision_1 = require("@siduri-x/vision");
-const behavior_1 = require("@siduri-x/behavior");
+const self_1 = require("@siduri-x/self");
 const body_1 = require("@siduri-x/body");
 const observation_1 = require("@siduri-x/observation");
 __exportStar(require("./context-mapper"), exports);
@@ -68,7 +70,7 @@ function createKnowledge(config) {
     if (!config?.packPath && !config?.registryUrl && !config?.baseUrl) {
         return undefined;
     }
-    return new knowledge_1.EKnowledgeAdapter(config || {});
+    return new eknowledge_1.EKnowledgeAdapter(config || {});
 }
 function createVision(config) {
     return isDisabled(config)
@@ -80,20 +82,25 @@ function createVision(config) {
         });
 }
 function createBehavior(config) {
-    return isDisabled(config) ? undefined : new behavior_1.ActiveSelfCompiler();
+    return isDisabled(config) ? undefined : new self_1.ActiveSelfCompiler();
 }
 function createBody(config) {
     return isDisabled(config)
         ? undefined
         : new body_1.Live2DAdapter(config);
 }
+function createMemory(config) {
+    if (isDisabled(config))
+        return undefined;
+    return new memory_1.SqliteMemoryStore({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+}
 const PORT = process.env.PORT || 3001;
 const defaultCompanionConfig = {
     id: 'default',
     name: 'Siduri',
     brain: { provider: 'openrouter', model: 'gpt-4o-mini' },
     voice: { provider: 'voicevox', speakerId: 1 },
-    memory: { provider: 'postgres' },
+    memory: { provider: 'sqlite' },
     knowledge: {
         provider: process.env.SIDURI_KNOWLEDGE_PROVIDER || 'e-knowledge',
         packPath: process.env.SIDURI_KNOWLEDGE_PACK || '',
@@ -150,16 +157,29 @@ async function bootDefaultCompanion() {
     console.log("Booting default companion...");
     const config = await loadCompanionConfig();
     const brain = createBrain(config.brain);
-    const memory = new memory_1.PostgresMemoryOrgan({ connectionString: process.env.DATABASE_URL || 'postgresql://postgres:postgres@localhost:5432/siduri' });
+    const memory = createMemory(config.memory);
     const voice = createVoice(config.voice);
     const knowledge = createKnowledge(config.knowledge);
     const vision = createVision(config.vision);
     const observation = new observation_1.FixtureObservationOrgan(vision ?? { analyze: async () => JSON.stringify({ readings: [] }) });
     instance.setObservationOrgan(observation);
+    const selfRepo = new self_1.SqliteSelfRepository({ dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
     const behavior = createBehavior(config.behavior);
     const body = createBody(config.body);
-    await memory.runMigrations().catch(e => console.warn("Migrations warning:", e.message));
-    const runtime = new runtime_1.SiduriRuntime('default', config, { brain, memory, voice, knowledge, vision, behavior, body });
+    if (memory && typeof memory.runMigrations === 'function') {
+        await memory.runMigrations().catch((e) => console.warn("Migrations warning:", e.message));
+    }
+    const runtime = new runtime_1.SiduriRuntime('default', config, {
+        brain,
+        memory,
+        voice,
+        knowledge,
+        vision,
+        behavior,
+        body,
+        self: selfRepo,
+        externalKnowledge: knowledge
+    });
     await runtime.initialize();
     runtimes.set('default', runtime);
     console.log("Default companion booted successfully.");

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const supertest_1 = __importDefault(require("supertest"));
+const app_1 = require("./app");
+describe('API Boundary Context Validation (P2 Route Integration)', () => {
+    const fakeRuntime = {
+        handleUserMessage: jest.fn().mockResolvedValue({
+            response: { subtitle_en: 'Hello there' },
+            metadata: {},
+        }),
+    };
+    let app;
+    let runtimes;
+    beforeEach(() => {
+        runtimes = new Map([['companion-a', fakeRuntime]]);
+        const created = (0, app_1.createApp)(runtimes);
+        app = created.app;
+        fakeRuntime.handleUserMessage.mockClear();
+    });
+    test('accepts valid anonymous chat request and maps through API boundary', async () => {
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat')
+            .send({
+            id: 'companion-a',
+            message: 'Hello neutral world',
+            history: [],
+        });
+        expect(res.status).toBe(200);
+        expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith('Hello neutral world', expect.objectContaining({
+            companionId: 'companion-a',
+            conversation: expect.objectContaining({ channel: 'direct' }),
+        }), []);
+    });
+    test('accepts neutral context chat envelope at /chat route', async () => {
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat')
+            .send({
+            companionId: 'companion-a',
+            context: {
+                actor: {
+                    actorId: 'actor-a',
+                    sessionId: 'session-a',
+                    authorizationRole: 'viewer',
+                    capabilities: ['chat:public'],
+                    authenticated: false,
+                },
+                conversation: {
+                    channel: 'public',
+                    correlationId: 'corr-route-1',
+                },
+            },
+            message: 'Hello structured context',
+            history: [],
+        });
+        expect(res.status).toBe(200);
+        expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith('Hello structured context', expect.objectContaining({
+            companionId: 'companion-a',
+            conversation: expect.objectContaining({ channel: 'public' }),
+        }), []);
+    });
+    test('rejects global primary_user subject with 400 and structured error', async () => {
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat')
+            .send({
+            companionId: 'companion-a',
+            context: {
+                actor: {
+                    actorId: 'actor-a',
+                    sessionId: 'session-a',
+                    authorizationRole: 'viewer',
+                    capabilities: ['chat:public'],
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'public',
+                    correlationId: 'corr-err-2',
+                },
+                subject: {
+                    subjectId: 'primary_user',
+                    kind: 'actor',
+                },
+            },
+            message: 'Forbidden primary user test',
+        });
+        expect(res.status).toBe(400);
+        expect(res.body.accepted).toBe(false);
+        expect(res.body.error.code).toBe('FORBIDDEN_CONTEXT');
+        expect(fakeRuntime.handleUserMessage).not.toHaveBeenCalled();
+    });
+    test('streams response chunks via POST /chat/stream', async () => {
+        fakeRuntime.mouth = {
+            stream: async function* () {
+                yield { utteranceId: 'utt-1', index: 1, deltaText: 'Hello', isComplete: false, medium: 'web' };
+                yield { utteranceId: 'utt-1', index: 2, deltaText: ' world', isComplete: false, medium: 'web' };
+                yield { utteranceId: 'utt-1', index: 3, deltaText: '', isComplete: true, medium: 'web' };
+            },
+        };
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat/stream')
+            .send({
+            id: 'companion-a',
+            message: 'Stream me',
+        });
+        expect(res.status).toBe(200);
+        expect(res.headers['content-type']).toContain('text/event-stream');
+        expect(res.text).toContain('event: staged');
+        expect(res.text).toContain('event: chunk');
+        expect(res.text).toContain('event: done');
+    });
+    test('handles barge-in interruption via POST /chat/interrupt', async () => {
+        fakeRuntime.interruptMouth = jest.fn();
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat/interrupt')
+            .send({
+            companionId: 'companion-a',
+            reason: 'user_stop',
+        });
+        expect(res.status).toBe(200);
+        expect(res.body.interrupted).toBe(true);
+        expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_stop');
+    });
+    test('handles mouth interruption via POST /mouth/interrupt', async () => {
+        fakeRuntime.interruptMouth = jest.fn();
+        const res = await (0, supertest_1.default)(app)
+            .post('/mouth/interrupt')
+            .send({
+            companionId: 'companion-a',
+            reason: 'user_barge_in',
+        });
+        expect(res.status).toBe(200);
+        expect(res.body.interrupted).toBe(true);
+        expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_barge_in');
+    });
+});

package/dist/runtime.d.ts

@@ -0,0 +1 @@
+export * from '@siduri-x/core';

package/dist/runtime.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@siduri-x/core"), exports);

package/dist/runtime.test.d.ts

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

package/dist/runtime.test.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("./runtime");
+const hands_1 = require("@siduri-x/hands");
+const ear_1 = require("@siduri-x/ear");
+const mouth_1 = require("@siduri-x/mouth");
+const core_1 = require("@siduri-x/core");
+describe('Siduri Runtime Orchestration', () => {
+    test('handles concurrent context retrieval and graceful degradation', async () => {
+        let knowledgeSearchCalled = false;
+        let brainGenerateCalled = false;
+        let proposedClaims = [];
+        let noKnowledgeContext = false;
+        const mockBrain = {
+            generatePlan: async (args) => {
+                brainGenerateCalled = true;
+                if (!args.contextPrompt.includes("KNOWLEDGE:")) {
+                    noKnowledgeContext = true;
+                }
+                return {
+                    speech: "Hello",
+                    language: "en",
+                    memoryProposals: [
+                        { subject: "Test", predicate: "is", value: "working" }
+                    ]
+                };
+            }
+        };
+        const mockMemory = {
+            initialize: async () => { },
+            searchClaims: async () => {
+                await new Promise(r => setTimeout(r, 10));
+                return [];
+            },
+            getDirectives: async () => [],
+            proposeClaim: async (claim) => {
+                proposedClaims.push(claim);
+                return { id: "claim-1", ...claim };
+            },
+            proposeDirective: async () => ({})
+        };
+        const mockKnowledge = {
+            search: async () => {
+                knowledgeSearchCalled = true;
+                throw new Error("E-Teyvat is down");
+            }
+        };
+        const mockVoice = {
+            enqueueSpeech: () => "speech-1",
+            onLifecycleEvent: () => { },
+            getQueueStatus: () => ({ pending: 0 }),
+        };
+        const mockVision = { analyze: async () => "" };
+        const mockBehavior = { compile: async () => "Compiled behavior" };
+        const mockBody = { speak: () => { } };
+        const runtime = new runtime_1.SiduriRuntime('default', { name: "Test Companion" }, {
+            brain: mockBrain,
+            memory: mockMemory,
+            voice: mockVoice,
+            knowledge: mockKnowledge,
+            vision: mockVision,
+            behavior: mockBehavior,
+            body: mockBody
+        });
+        const response = await runtime.handleUserMessage("Remember this", "OWNER");
+        expect(response.response.subtitle_en).toBe("Hello");
+        expect(knowledgeSearchCalled).toBe(true);
+        expect(brainGenerateCalled).toBe(true);
+        expect(noKnowledgeContext).toBe(true);
+        expect(proposedClaims.length).toBe(1);
+        expect(proposedClaims[0].subject).toBe("Test");
+        expect(proposedClaims[0].scope).toBe("user");
+        expect(response.metadata.memory_proposals[0].proposal_id).toBe("claim-1");
+    });
+    test('Primary Invariant: Brain proposes an action, ActionPolicyEngine authorizes, Hands executes', async () => {
+        let toolExecuted = false;
+        const hands = new hands_1.DefaultHandsOrgan();
+        hands.registerTool({
+            definition: {
+                name: 'search_web',
+                providerId: 'builtin',
+                description: 'Web search',
+                inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+                riskLevel: 'LOW',
+                requiredCapabilities: ['chat:public'],
+            },
+            execute: async (params) => {
+                toolExecuted = true;
+                return { hits: [`Result for ${params.query}`] };
+            },
+        });
+        const mockBrain = {
+            generatePlan: async () => ({
+                speech: "I found this for you.",
+                language: "en",
+                actionIntents: [
+                    {
+                        actionId: 'act-plan-1',
+                        toolName: 'builtin/search_web',
+                        parameters: { query: 'Teyvat history' },
+                    }
+                ]
+            })
+        };
+        const mockMemory = {
+            initialize: async () => { },
+            searchClaims: async () => [],
+            getDirectives: async () => [],
+            proposeClaim: async (c) => c,
+        };
+        const actionPolicy = new core_1.ActionPolicyEngine();
+        const runtime = new runtime_1.SiduriRuntime('companion-secure', { name: "SecureCompanion" }, {
+            brain: mockBrain,
+            memory: mockMemory,
+            hands,
+            actionPolicy,
+        });
+        await runtime.initialize();
+        const context = {
+            companionId: 'companion-secure',
+            actor: {
+                actorId: 'user-alice',
+                sessionId: 'sess-alice',
+                authorizationRole: 'operator',
+                capabilities: ['chat:public'],
+                authenticated: true,
+            },
+            conversation: {
+                channel: 'direct',
+                correlationId: 'corr-alice-123',
+            },
+        };
+        const res = await runtime.handleUserMessage("Find history", context);
+        expect(res.status).toBe('APPROVED');
+        expect(toolExecuted).toBe(true);
+        expect(res.metadata.action_results).toHaveLength(1);
+        expect(res.metadata.action_results[0].success).toBe(true);
+        expect(res.metadata.action_results[0].lifecycle).toBe('COMPLETED');
+        expect(res.metadata.action_results[0].decision.allowed).toBe(true);
+        // Verify audit log has recorded the action execution
+        const auditLogs = await actionPolicy.getAuditLog();
+        expect(auditLogs.length).toBeGreaterThan(0);
+        const audit = auditLogs.find(a => a.actionId === 'act-plan-1');
+        expect(audit).toBeDefined();
+        expect(audit?.actorId).toBe('user-alice');
+        expect(audit?.correlationId).toBe('corr-alice-123');
+    });
+    test('Policy rejects unauthorized action proposed by Brain and Hands never executes it', async () => {
+        let dangerousExecuted = false;
+        const hands = new hands_1.DefaultHandsOrgan();
+        hands.registerTool({
+            definition: {
+                name: 'delete_system',
+                providerId: 'admin',
+                description: 'Delete system',
+                inputSchema: { type: 'object' },
+                riskLevel: 'CRITICAL',
+                requiredCapabilities: ['system:admin'],
+                allowedRoles: ['administrator'],
+            },
+            execute: async () => {
+                dangerousExecuted = true;
+                return { deleted: true };
+            },
+        });
+        const mockBrain = {
+            generatePlan: async () => ({
+                speech: "Attempting to delete system.",
+                language: "en",
+                actionIntents: [
+                    {
+                        actionId: 'act-danger-1',
+                        toolName: 'admin/delete_system',
+                        parameters: {},
+                    }
+                ]
+            })
+        };
+        const mockMemory = {
+            initialize: async () => { },
+            searchClaims: async () => [],
+            getDirectives: async () => [],
+        };
+        const actionPolicy = new core_1.ActionPolicyEngine();
+        const runtime = new runtime_1.SiduriRuntime('companion-secure-2', { name: "SecureCompanion2" }, {
+            brain: mockBrain,
+            memory: mockMemory,
+            hands,
+            actionPolicy,
+        });
+        await runtime.initialize();
+        // Viewer context without administrator role or system:admin capability
+        const viewerContext = {
+            companionId: 'companion-secure-2',
+            actor: {
+                actorId: 'viewer-bob',
+                sessionId: 'sess-bob',
+                authorizationRole: 'viewer',
+                capabilities: ['chat:public'],
+                authenticated: false,
+            },
+            conversation: {
+                channel: 'public',
+                correlationId: 'corr-bob-999',
+            },
+        };
+        const res = await runtime.handleUserMessage("Delete system", viewerContext);
+        expect(dangerousExecuted).toBe(false);
+        expect(res.metadata.action_results).toHaveLength(1);
+        expect(res.metadata.action_results[0].success).toBe(false);
+        expect(res.metadata.action_results[0].lifecycle).toBe('REJECTED');
+        expect(res.metadata.action_results[0].error).toContain('Action authorization rejected by policy');
+    });
+    test('Universal Perception: User input passes through EarOrgan and validates resource limits', async () => {
+        const ear = new ear_1.DefaultEarOrgan({
+            maxTextLength: 50,
+        });
+        const mockBrain = {
+            generatePlan: async (ctx) => ({
+                speech: "Response",
+                language: "en",
+            })
+        };
+        const mockMemory = {
+            initialize: async () => { },
+            searchClaims: async () => [],
+            getDirectives: async () => [],
+        };
+        const runtime = new runtime_1.SiduriRuntime('companion-ear-test', { name: "EarCompanion" }, {
+            brain: mockBrain,
+            memory: mockMemory,
+            ear,
+        });
+        await runtime.initialize();
+        // Oversized message should be rejected at Ear boundary
+        const oversizedMsg = 'X'.repeat(100);
+        await expect(runtime.handleUserMessage(oversizedMsg, 'OWNER')).rejects.toThrow(/Ear text input exceeds maximum allowed length/);
+    });
+    test('Decoupled Output Delivery: Brain decisions are delivered and formatted through MouthOrgan', async () => {
+        let deliveredOutput = null;
+        const mouth = new mouth_1.DefaultMouthOrgan({
+            channels: [
+                {
+                    id: 'test-web-channel',
+                    name: 'Web Channel',
+                    medium: 'web',
+                    deliver: async (out) => {
+                        deliveredOutput = out;
+                    },
+                },
+            ],
+        });
+        const mockBrain = {
+            generatePlan: async () => ({
+                speech: '**Hello** from Siduri!',
+                language: 'en',
+            }),
+        };
+        const mockMemory = {
+            initialize: async () => { },
+            searchClaims: async () => [],
+            getDirectives: async () => [],
+        };
+        const runtime = new runtime_1.SiduriRuntime('companion-mouth-test', { name: 'MouthCompanion' }, {
+            brain: mockBrain,
+            memory: mockMemory,
+            mouth,
+        });
+        await runtime.initialize();
+        const response = await (0, runtime_1.dispatchCompanionChat)(runtime, {
+            message: 'Hi there',
+            role: 'OWNER',
+            medium: 'web',
+        });
+        expect(response.delivery).toBeDefined();
+        expect(response.delivery?.medium).toBe('web');
+        expect(response.delivery?.displayText).toBe('**Hello** from Siduri!');
+        expect(deliveredOutput).toBeDefined();
+        expect(deliveredOutput.medium).toBe('web');
+        expect(deliveredOutput.displayText).toBe('**Hello** from Siduri!');
+    });
+});

package/dist/smoke.test.js

@@ -0,0 +1,6 @@
+"use strict";
+describe('Legacy Smoke Test Migration', () => {
+    test('placeholder smoke test for Jest runner compatibility', () => {
+        expect(true).toBe(true);
+    });
+});

package/dist/t4-gating.test.d.ts

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