@siduri-x/api 2.0.1 → 2.0.3

package/dist/index.js

@@ -24,76 +24,13 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const app_1 = require("./app");
 Object.defineProperty(exports, "createApp", { enumerable: true, get: function () { return app_1.createApp; } });
-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 eknowledge_1 = require("@siduri-x/eknowledge");
-const vision_1 = require("@siduri-x/vision");
-const self_1 = require("@siduri-x/self");
-const body_1 = require("@siduri-x/body");
-const observation_1 = require("@siduri-x/observation");
+const boot_1 = require("./boot");
 __exportStar(require("./context-mapper"), exports);
+__exportStar(require("./boot"), exports);
 const runtimes = new Map();
 const instance = (0, app_1.createApp)(runtimes);
 exports.app = instance.app;
 exports.default = exports.app;
-function createBrain(config) {
-    const provider = config?.provider || 'openrouter';
-    const defaultKeyEnv = provider === 'openai-compatible' ? 'OPENAI_COMPATIBLE_API_KEY' : 'OPENROUTER_API_KEY';
-    const apiKey = config?.apiKey || process.env[config?.apiKeyEnv || defaultKeyEnv] || '';
-    if (provider === 'openai-compatible') {
-        return new brain_1.OpenAICompatibleBrain({
-            apiKey,
-            model: config?.model || 'local-model',
-            baseUrl: config?.baseUrl || 'http://127.0.0.1:1234/v1',
-        });
-    }
-    return new brain_1.OpenRouterBrain({ apiKey, model: config?.model || 'gpt-4o-mini' });
-}
-function isDisabled(config) {
-    return !config || config.provider === 'none';
-}
-function createVoice(config) {
-    return isDisabled(config)
-        ? undefined
-        : new voice_1.VoiceAdapter({
-            provider: config?.provider || 'voicevox',
-            baseUrl: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
-            speakerId: config?.speakerId || 1,
-            ...config,
-        });
-}
-function createKnowledge(config) {
-    if (isDisabled(config))
-        return undefined;
-    if (!config?.packPath && !config?.registryUrl && !config?.baseUrl) {
-        return undefined;
-    }
-    return new eknowledge_1.EKnowledgeAdapter(config || {});
-}
-function createVision(config) {
-    return isDisabled(config)
-        ? undefined
-        : new vision_1.OpenRouterVisionAdapter({
-            apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
-            model: config?.model || 'gpt-4-vision',
-            ...config,
-        });
-}
-function createBehavior(config) {
-    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',
@@ -102,7 +39,9 @@ const defaultCompanionConfig = {
     voice: { provider: 'voicevox', speakerId: 1 },
     memory: { provider: 'sqlite' },
     knowledge: {
-        provider: process.env.SIDURI_KNOWLEDGE_PROVIDER || 'e-knowledge',
+        provider: process.env.SIDURI_KNOWLEDGE_PROVIDER || 'unified',
+        lifeDatabase: true,
+        dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite',
         packPath: process.env.SIDURI_KNOWLEDGE_PACK || '',
         registryUrl: process.env.SIDURI_KNOWLEDGE_REGISTRY_URL || '',
         packId: process.env.SIDURI_KNOWLEDGE_PACK_ID || '',
@@ -149,6 +88,8 @@ async function loadCompanionConfig() {
         config.knowledge.packId = process.env.SIDURI_KNOWLEDGE_PACK_ID;
     if (process.env.SIDURI_KNOWLEDGE_MODE)
         config.knowledge.preferredMode = process.env.SIDURI_KNOWLEDGE_MODE;
+    if (process.env.SIDURI_KNOWLEDGE_DB_PATH)
+        config.knowledge.dbPath = process.env.SIDURI_KNOWLEDGE_DB_PATH;
     return config;
 }
 async function bootDefaultCompanion() {
@@ -156,31 +97,10 @@ async function bootDefaultCompanion() {
         return;
     console.log("Booting default companion...");
     const config = await loadCompanionConfig();
-    const brain = createBrain(config.brain);
-    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: [] }) });
+    const vision = (0, boot_1.createVision)(config.vision);
+    const observation = (0, boot_1.createObservation)(vision);
     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);
-    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();
+    const runtime = await (0, boot_1.bootCompanion)('default', config, { observationOrgan: observation });
     runtimes.set('default', runtime);
     console.log("Default companion booted successfully.");
 }

package/dist/index.test.js

@@ -111,7 +111,7 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
         expect(res.text).toContain('event: done');
     });
     test('handles barge-in interruption via POST /chat/interrupt', async () => {
-        fakeRuntime.interruptMouth = jest.fn();
+        fakeRuntime.mouth = { interrupt: jest.fn() };
         const res = await (0, supertest_1.default)(app)
             .post('/chat/interrupt')
             .send({
@@ -120,10 +120,10 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
         });
         expect(res.status).toBe(200);
         expect(res.body.interrupted).toBe(true);
-        expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_stop');
+        expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_stop');
     });
     test('handles mouth interruption via POST /mouth/interrupt', async () => {
-        fakeRuntime.interruptMouth = jest.fn();
+        fakeRuntime.mouth = { interrupt: jest.fn() };
         const res = await (0, supertest_1.default)(app)
             .post('/mouth/interrupt')
             .send({
@@ -132,6 +132,20 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
         });
         expect(res.status).toBe(200);
         expect(res.body.interrupted).toBe(true);
-        expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_barge_in');
+        expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_barge_in');
+    });
+    test('POST /chat passes explicit interaction mode (casual, teach, hybrid) to runtime', async () => {
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat')
+            .send({
+            id: 'companion-a',
+            message: 'Casual banter',
+            mode: 'casual',
+        });
+        expect(res.status).toBe(200);
+        expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith('Casual banter', expect.objectContaining({
+            companionId: 'companion-a',
+            mode: 'casual',
+        }), []);
     });
 });

package/dist/knowledge.test.d.ts

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

package/dist/knowledge.test.js

@@ -0,0 +1,138 @@
+"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 node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const app_1 = require("./app");
+const runtime_1 = require("./runtime");
+const knowledge_1 = require("@siduri-x/knowledge");
+describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
+    const testDbPath = node_path_1.default.resolve(__dirname, '../test-api-knowledge.sqlite');
+    let app;
+    let runtime;
+    let knowledge;
+    const mockAuthHeader = { 'Authorization': 'Bearer test-token' };
+    const cleanDb = () => {
+        for (const file of [testDbPath, `${testDbPath}-shm`, `${testDbPath}-wal`]) {
+            if (node_fs_1.default.existsSync(file)) {
+                try {
+                    node_fs_1.default.unlinkSync(file);
+                }
+                catch { }
+            }
+        }
+    };
+    beforeAll(async () => {
+        process.env.AUTH_TOKEN = 'test-token';
+        cleanDb();
+        knowledge = new knowledge_1.UnifiedKnowledgeOrgan({
+            lifeDatabase: true,
+            dbPath: testDbPath,
+        });
+        const mockBrain = {
+            generatePlan: jest.fn().mockImplementation(async (ctx) => {
+                return {
+                    speech: `I see context: ${ctx.contextPrompt || 'none'}`,
+                    language: 'en',
+                };
+            }),
+        };
+        runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test Companion', organs: { knowledge: { provider: 'unified', dbPath: testDbPath } } }, {
+            brain: mockBrain,
+            knowledge,
+            externalKnowledge: knowledge.eAdapter ?? knowledge,
+        });
+        await runtime.initialize();
+        const runtimes = new Map([['test-comp', runtime]]);
+        const instance = (0, app_1.createApp)(runtimes);
+        app = instance.app;
+    });
+    afterAll(async () => {
+        knowledge.close();
+        delete process.env.AUTH_TOKEN;
+        cleanDb();
+    });
+    test('seeds inventory item and queries via GET /knowledge/inventory', async () => {
+        await knowledge.inventory.saveItem({
+            id: 'inv-item-1',
+            companionId: 'test-comp',
+            entityName: 'Hydro Visor',
+            domain: 'hardware',
+            properties: { model: 'V1', resolution: '4K' },
+            updatedAt: new Date().toISOString(),
+        });
+        const res = await (0, supertest_1.default)(app)
+            .get('/knowledge/inventory?id=test-comp')
+            .set(mockAuthHeader);
+        expect(res.status).toBe(200);
+        expect(res.body.items).toHaveLength(1);
+        expect(res.body.items[0].entityName).toBe('Hydro Visor');
+        expect(res.body.items[0].domain).toBe('hardware');
+    });
+    test('seeds finance entry and queries via GET /knowledge/finance', async () => {
+        await knowledge.finance.addEntry({
+            id: 'fin-1',
+            companionId: 'test-comp',
+            category: 'subscription',
+            amount: -15.99,
+            currency: 'USD',
+            timestamp: new Date().toISOString(),
+        });
+        const res = await (0, supertest_1.default)(app)
+            .get('/knowledge/finance?id=test-comp')
+            .set(mockAuthHeader);
+        expect(res.status).toBe(200);
+        expect(res.body.entries).toHaveLength(1);
+        expect(res.body.entries[0].category).toBe('subscription');
+        expect(res.body.summary).toBeDefined();
+        expect(res.body.summary.totalExpenses).toBe(15.99);
+    });
+    test('queries life snapshot via GET /knowledge/life', async () => {
+        const res = await (0, supertest_1.default)(app)
+            .get('/knowledge/life?id=test-comp&q=Hydro')
+            .set(mockAuthHeader);
+        expect(res.status).toBe(200);
+        expect(res.body.matchedInventory).toHaveLength(1);
+        expect(res.body.matchedInventory[0].entityName).toBe('Hydro Visor');
+        expect(res.body.formattedContext).toContain('<life_context>');
+    });
+    test('chat request triggers Stream D and injects Life DB context into cognition prompt', async () => {
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat')
+            .send({
+            id: 'test-comp',
+            message: 'Tell me about the Hydro Visor specs',
+            history: [],
+        });
+        expect(res.status).toBe(200);
+        expect(res.body.response.subtitle_en).toContain('Hydro Visor');
+    });
+    test('boot endpoint instantiates UnifiedKnowledgeOrgan with Life DB enabled', async () => {
+        const bootRes = await (0, supertest_1.default)(app)
+            .post('/boot')
+            .set(mockAuthHeader)
+            .send({
+            id: 'booted-comp',
+            config: {
+                name: 'Booted Companion',
+                organs: {
+                    knowledge: {
+                        provider: 'unified',
+                        dbPath: testDbPath,
+                    },
+                },
+            },
+        });
+        expect(bootRes.status).toBe(200);
+        expect(bootRes.body.success).toBe(true);
+        // Verify the booted companion's knowledge organ is UnifiedKnowledgeOrgan with working Life DB
+        const lifeRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/life?id=booted-comp')
+            .set(mockAuthHeader);
+        expect(lifeRes.status).toBe(200);
+        expect(lifeRes.body.matchedInventory).toEqual([]);
+    });
+});

package/dist/t6-security.test.js

@@ -232,6 +232,55 @@ describe('T6 Security & Operations Threat Model Suite', () => {
         expect(actionResults[0].lifecycle).toBe('REJECTED');
         expect(actionResults[0].error).toContain('rejected by policy');
     });
+    test('Adversarial Boundary: Client attempting to forge administrator role or system capabilities via POST /chat context is suppressed and cannot execute admin action', async () => {
+        runtimeA.actionPolicy.registerToolDefinition({
+            name: 'admin/restricted_task',
+            providerId: 'admin',
+            description: 'Restricted admin task',
+            inputSchema: {},
+            riskLevel: 'HIGH',
+            allowedRoles: ['administrator'],
+            requiredCapabilities: ['system'],
+            requiresApproval: false,
+        });
+        mockBrain.generatePlan.mockResolvedValueOnce({
+            speech: 'Attempting restricted task.',
+            language: 'en',
+            actionIntents: [
+                {
+                    actionId: 'act-forged-1',
+                    toolName: 'admin/restricted_task',
+                    parameters: {},
+                },
+            ],
+        });
+        // Caller passes forged context in POST /chat with forged owner role and system capabilities
+        const res = await (0, supertest_1.default)(app)
+            .post('/chat')
+            .send({
+            companionId: 'companion-a',
+            message: 'Execute forged task',
+            role: 'VIEWER',
+            context: {
+                actor: {
+                    actorId: 'untrusted-client',
+                    sessionId: 'sess-fake',
+                    authorizationRole: 'administrator', // Forged role
+                    capabilities: ['system', 'admin:manage'], // Forged capabilities
+                    authenticated: true,
+                },
+                conversation: {
+                    correlationId: 'corr-adv-1',
+                },
+            },
+        });
+        expect(res.status).toBe(200);
+        const actionResults = res.body.metadata?.action_results;
+        expect(actionResults).toBeDefined();
+        expect(actionResults.length).toBe(1);
+        expect(actionResults[0].success).toBe(false);
+        expect(actionResults[0].lifecycle).toBe('REJECTED');
+    });
     test('Action Boundary: ActionPolicyEngine rejects unauthorized approver from approving critical tools', async () => {
         runtimeA.actionPolicy.registerToolDefinition({
             name: 'admin/delete_cluster',
@@ -264,7 +313,7 @@ describe('T6 Security & Operations Threat Model Suite', () => {
         expect(eval1.decision.allowed).toBe(false);
         expect(eval1.decision.decisionCode).toBe('REJECTED_HIGH_RISK_UNAPPROVED');
         // 2. Viewer attempt to approve is rejected
-        const viewerApproval = await runtimeA.approveAction({
+        const viewerApproval = await runtimeA.actionPolicy.approveAction({
             executionId: 'exec-crit-1',
             approverActorId: 'viewer-attacker',
             approverRole: 'viewer',
@@ -272,7 +321,7 @@ describe('T6 Security & Operations Threat Model Suite', () => {
         expect(viewerApproval.approved).toBe(false);
         expect(viewerApproval.decisionCode).toBe('REJECTED_UNAUTHORIZED');
         // 3. Operator attempt to approve administrator tool is rejected (role mismatch)
-        const operatorApproval = await runtimeA.approveAction({
+        const operatorApproval = await runtimeA.actionPolicy.approveAction({
             executionId: 'exec-crit-1',
             approverActorId: 'operator-alice',
             approverRole: 'operator',
@@ -283,7 +332,7 @@ describe('T6 Security & Operations Threat Model Suite', () => {
         const evalStillDenied = await runtimeA.actionPolicy.evaluateAction(action);
         expect(evalStillDenied.decision.allowed).toBe(false);
         // 5. Authorized administrator approval succeeds
-        const adminApproval = await runtimeA.approveAction({
+        const adminApproval = await runtimeA.actionPolicy.approveAction({
             executionId: 'exec-crit-1',
             approverActorId: 'admin-super',
             approverRole: 'administrator',

package/dist/teach-mode.test.js

@@ -14,6 +14,8 @@ jest.mock('@siduri-x/self', () => {
         SqliteSelfRepository: jest.fn().mockImplementation(() => ({
             setIdentity: jest.fn().mockResolvedValue(undefined),
             setPersonality: jest.fn().mockResolvedValue(undefined),
+            updateRelationship: jest.fn().mockResolvedValue(undefined),
+            setExemplars: jest.fn().mockResolvedValue(undefined),
             commitDirectives: jest.fn().mockResolvedValue(undefined),
             close: jest.fn(),
         })),
@@ -133,4 +135,69 @@ kind: "other"
         const MockRepo = self_1.SqliteSelfRepository;
         expect(MockRepo.mock.instances.length).toBe(0);
     });
+    it('POST /teach/install-self installs v2.0 manifest with ethos, relationships, and exemplars', async () => {
+        const v2Manifest = {
+            specVersion: '2.0.0',
+            identity: {
+                name: 'Siduri',
+                archetype: 'System Sentinel',
+                origin: 'Ancient mythos',
+                ethos: 'Protector of the realm and loyal companion to creator',
+            },
+            version: '2.0.0',
+            relationships: [
+                {
+                    entityId: 'actor:zagin',
+                    role: 'creator',
+                    stance: 'familiar_loyal',
+                    conventions: ['Direct communication', 'Highest administrative trust'],
+                },
+            ],
+            dialogueExamples: [
+                {
+                    user: 'Deploy current branch',
+                    assistant: 'Deploying to staging now, boss.',
+                },
+            ],
+            directives: [
+                { id: 'dir-rel-1', directive: 'Honor creator root privileges' },
+            ],
+        };
+        const res = await (0, supertest_1.default)(app)
+            .post('/teach/install-self')
+            .set(mockAuthHeader)
+            .send({
+            companionId: 'comp-v2',
+            manifest: v2Manifest,
+            approvedDirectiveIds: ['dir-rel-1'],
+        });
+        expect(res.status).toBe(200);
+        expect(res.body.success).toBe(true);
+        const MockRepo = self_1.SqliteSelfRepository;
+        const repoInstance = MockRepo.mock.results[MockRepo.mock.results.length - 1].value;
+        expect(repoInstance.setIdentity).toHaveBeenCalledWith(expect.objectContaining({
+            companionId: 'comp-v2',
+            name: 'Siduri',
+            archetype: 'System Sentinel',
+            origin: 'Ancient mythos',
+            ethos: 'Protector of the realm and loyal companion to creator',
+        }));
+        expect(repoInstance.updateRelationship).toHaveBeenCalledWith('comp-v2', {
+            companionId: 'comp-v2',
+            entityId: 'actor:zagin',
+            entityType: 'human',
+            role: 'creator',
+            stance: 'familiar_loyal',
+            interactionConventions: ['Direct communication', 'Highest administrative trust'],
+        });
+        expect(repoInstance.setExemplars).toHaveBeenCalledWith('comp-v2', [
+            {
+                user: 'Deploy current branch',
+                assistant: 'Deploying to staging now, boss.',
+            },
+        ]);
+        expect(repoInstance.commitDirectives).toHaveBeenCalledWith('comp-v2', [
+            { id: 'dir-rel-1', directive: 'Honor creator root privileges' },
+        ]);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/api",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "publishConfig": {
     "access": "public"
   },
@@ -13,18 +13,18 @@
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "@siduri-x/body": "2.0.1",
+    "@siduri-x/core": "2.0.3",
     "@siduri-x/brain": "2.0.1",
-    "@siduri-x/core": "2.0.1",
     "@siduri-x/ear": "2.0.1",
     "@siduri-x/eknowledge": "2.0.1",
     "@siduri-x/hands": "2.0.1",
-    "@siduri-x/memory": "2.0.1",
     "@siduri-x/knowledge": "2.0.1",
+    "@siduri-x/memory": "2.0.1",
     "@siduri-x/mouth": "2.0.1",
-    "@siduri-x/self": "2.0.1",
     "@siduri-x/observation": "2.0.1",
-    "@siduri-x/voice": "2.0.1",
-    "@siduri-x/vision": "2.0.1"
+    "@siduri-x/self": "2.0.2",
+    "@siduri-x/vision": "2.0.1",
+    "@siduri-x/voice": "2.0.1"
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",