@siduri-x/api 1.0.2 → 1.0.5

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

@@ -0,0 +1,191 @@
+"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 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 knowledge_1 = require("@siduri-x/knowledge");
+const vision_1 = require("@siduri-x/vision");
+const behavior_1 = require("@siduri-x/behavior");
+const body_1 = require("@siduri-x/body");
+const observation_1 = require("@siduri-x/observation");
+__exportStar(require("./context-mapper"), 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 knowledge_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 behavior_1.ActiveSelfCompiler();
+}
+function createBody(config) {
+    return isDisabled(config)
+        ? undefined
+        : new body_1.Live2DAdapter(config);
+}
+function createMemory(config) {
+    if (isDisabled(config))
+        return undefined;
+    const provider = config?.provider || 'postgres';
+    if (provider === 'in-memory') {
+        return new memory_1.InMemoryMemoryOrgan();
+    }
+    if (provider === 'postgres') {
+        const connectionString = config?.connectionString || process.env.DATABASE_URL || 'postgresql://postgres:postgres@localhost:5432/siduri';
+        return new memory_1.PostgresMemoryOrgan({ connectionString, maxConnections: config?.maxConnections });
+    }
+    return undefined;
+}
+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' },
+    knowledge: {
+        provider: process.env.SIDURI_KNOWLEDGE_PROVIDER || 'e-knowledge',
+        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;
+    return config;
+}
+async function bootDefaultCompanion() {
+    if (runtimes.has('default'))
+        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: [] }) });
+    instance.setObservationOrgan(observation);
+    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 });
+    await runtime.initialize();
+    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,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 {};