@sidurijs/api 1.0.0

package/dist/index.js

@@ -0,0 +1,116 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = exports.createApp = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config({ override: true });
+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 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;
+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: 'sqlite' },
+    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 || '',
+        timeoutMs: Number(process.env.SIDURI_KNOWLEDGE_TIMEOUT_MS || 5000),
+        preferredMode: process.env.SIDURI_KNOWLEDGE_MODE || 'lexical',
+    },
+    behavior: { provider: 'active_self' },
+    body: {
+        provider: 'live2d',
+    },
+    vision: { provider: 'openrouter', model: 'gpt-4-vision' }
+};
+async function loadCompanionConfig() {
+    const configPath = process.env.SIDURI_CONFIG || node_path_1.default.resolve(process.cwd(), 'siduri.config.json');
+    let fileConfig = {};
+    try {
+        fileConfig = JSON.parse(await (0, promises_1.readFile)(configPath, 'utf8'));
+        console.log(`Loaded companion configuration from ${configPath}`);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw new Error(`Unable to read ${configPath}: ${error.message}`);
+        console.log(`No ${configPath} found; using environment/default configuration.`);
+    }
+    const config = {
+        ...defaultCompanionConfig,
+        ...fileConfig,
+        id: fileConfig.id || defaultCompanionConfig.id,
+        brain: { ...defaultCompanionConfig.brain, ...fileConfig.brain },
+        voice: { ...defaultCompanionConfig.voice, ...fileConfig.voice },
+        memory: { ...defaultCompanionConfig.memory, ...fileConfig.memory },
+        knowledge: { ...defaultCompanionConfig.knowledge, ...fileConfig.knowledge },
+        behavior: { ...defaultCompanionConfig.behavior, ...fileConfig.behavior },
+        body: { ...defaultCompanionConfig.body, ...fileConfig.body },
+        vision: { ...defaultCompanionConfig.vision, ...fileConfig.vision },
+    };
+    if (process.env.SIDURI_KNOWLEDGE_PROVIDER)
+        config.knowledge.provider = process.env.SIDURI_KNOWLEDGE_PROVIDER;
+    if (process.env.SIDURI_KNOWLEDGE_PACK)
+        config.knowledge.packPath = process.env.SIDURI_KNOWLEDGE_PACK;
+    if (process.env.SIDURI_KNOWLEDGE_REGISTRY_URL)
+        config.knowledge.registryUrl = process.env.SIDURI_KNOWLEDGE_REGISTRY_URL;
+    if (process.env.SIDURI_KNOWLEDGE_PACK_ID)
+        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() {
+    if (runtimes.has('default'))
+        return;
+    console.log("Booting default companion...");
+    const config = await loadCompanionConfig();
+    const vision = (0, boot_1.createVision)(config.vision);
+    const observation = (0, boot_1.createObservation)(vision);
+    instance.setObservationOrgan(observation);
+    const runtime = await (0, boot_1.bootCompanion)('default', config, { observationOrgan: observation });
+    runtimes.set('default', runtime);
+    console.log("Default companion booted successfully.");
+}
+if (process.env.NODE_ENV !== 'test') {
+    bootDefaultCompanion().then(() => {
+        exports.app.listen(Number(PORT), '127.0.0.1', () => {
+            console.log(`Siduri-X API running on port ${PORT} (127.0.0.1)`);
+        });
+    }).catch(e => {
+        console.error("Failed to boot default companion:", e);
+        process.exit(1);
+    });
+}

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -0,0 +1,151 @@
+"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.mouth = { interrupt: 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.mouth.interrupt).toHaveBeenCalledWith('user_stop');
+    });
+    test('handles mouth interruption via POST /mouth/interrupt', async () => {
+        fakeRuntime.mouth = { interrupt: 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.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,236 @@
+"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("@sidurijs/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',
+                };
+            }),
+        };
+        const memory = {
+            initialize: async () => { },
+            proposeClaim: async (claim) => knowledge.lifeDb.db.proposeClaim(claim),
+            getClaims: async (limit) => knowledge.lifeDb.db.getAllClaims(undefined, limit || 500),
+            getPendingClaims: async (limit) => knowledge.lifeDb.db.getAllClaims(undefined, limit || 500).filter((c) => c.status === 'pending'),
+            approveClaim: async (id) => knowledge.lifeDb.db.approveClaim(id),
+            rejectClaim: async (id) => knowledge.lifeDb.db.rejectClaim(id),
+            searchClaims: async () => [],
+            getApprovedClaims: async () => [],
+            getDirectives: async () => [],
+        };
+        runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test Companion', organs: { knowledge: { provider: 'unified', dbPath: testDbPath } } }, {
+            brain: mockBrain,
+            knowledge,
+            externalKnowledge: knowledge.eAdapter ?? knowledge,
+            memory,
+        });
+        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([]);
+    });
+    test('seeds and queries generic entities, events, and tasks', async () => {
+        // 1. Entities
+        await knowledge.entities.saveEntity({
+            id: 'ent-1',
+            companionId: 'test-comp',
+            name: 'Coffee Grinder',
+            entityType: 'item',
+            domain: 'kitchen',
+            properties: { burr: 'conical', setting: 14 },
+        });
+        const entRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/entities?id=test-comp&domain=kitchen')
+            .set(mockAuthHeader);
+        expect(entRes.status).toBe(200);
+        expect(entRes.body.entities).toHaveLength(1);
+        expect(entRes.body.entities[0].name).toBe('Coffee Grinder');
+        expect(entRes.body.entities[0].properties.setting).toBe(14);
+        // 2. Events
+        await knowledge.events.addEvent({
+            id: 'evt-1',
+            companionId: 'test-comp',
+            stream: 'health:heartrate',
+            timestamp: new Date().toISOString(),
+            metricValue: 72,
+            metadata: { unit: 'bpm' },
+        });
+        const evtRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/events?id=test-comp&stream=health:heartrate')
+            .set(mockAuthHeader);
+        expect(evtRes.status).toBe(200);
+        expect(evtRes.body.events).toHaveLength(1);
+        expect(evtRes.body.events[0].metricValue).toBe(72);
+        // 3. Tasks
+        await knowledge.tasks.saveTask({
+            id: 'task-1',
+            companionId: 'test-comp',
+            title: 'Order fresh espresso beans',
+            status: 'pending',
+            priority: 2,
+        });
+        const taskRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/tasks?id=test-comp&status=pending')
+            .set(mockAuthHeader);
+        expect(taskRes.status).toBe(200);
+        expect(taskRes.body.tasks).toHaveLength(1);
+        expect(taskRes.body.tasks[0].title).toBe('Order fresh espresso beans');
+    });
+    test('Truth Gate candidate proposal approval commits Life DB mutations', async () => {
+        // Stage a candidate proposal targeting Life DB
+        const proposal = await knowledge.lifeDb.db.proposeClaim({
+            id: 'prop-task-gate',
+            companionId: 'test-comp',
+            subject: 'task:buy-filter',
+            predicate: 'is',
+            value: 'Buy paper filters',
+            status: 'pending',
+            evidence: {
+                type: 'task',
+                title: 'Buy paper filters',
+                status: 'todo',
+                priority: 1,
+            },
+        });
+        expect(proposal.status).toBe('pending');
+        // Confirm it is not yet in tasks
+        const beforeRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/tasks?id=test-comp')
+            .set(mockAuthHeader);
+        expect(beforeRes.body.tasks.some((t) => t.title === 'Buy paper filters')).toBe(false);
+        // Approve via Truth Gate endpoint
+        const approveRes = await (0, supertest_1.default)(app)
+            .post('/knowledge/proposals/approve')
+            .set(mockAuthHeader)
+            .send({ companionId: 'test-comp', id: 'prop-task-gate' });
+        expect(approveRes.status).toBe(200);
+        expect(approveRes.body.approved).toBe(true);
+        expect(approveRes.body.target).toBe('knowledge');
+        // Confirm it is committed to Life DB tasks
+        const afterRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/tasks?id=test-comp')
+            .set(mockAuthHeader);
+        expect(afterRes.status).toBe(200);
+        const approvedTask = afterRes.body.tasks.find((t) => t.title === 'Buy paper filters');
+        expect(approvedTask).toBeDefined();
+        expect(approvedTask.status).toBe('todo');
+    });
+});

package/dist/runtime.d.ts

@@ -0,0 +1 @@
+export * from '@sidurijs/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("@sidurijs/core"), exports);

package/dist/runtime.test.d.ts

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