@siduri-x/api 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,167 +0,0 @@
-"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.VoicevoxAdapter({ baseUrl: process.env.VOICEVOX_URL || 'http://localhost:50021', speakerId: config.speakerId || 1 });
-}
-function createKnowledge(config) {
-    if (isDisabled(config))
-        return undefined;
-    if (!config?.packPath && !config?.registryUrl && !config?.baseUrl && !config?.hubUrl) {
-        return undefined;
-    }
-    return new knowledge_1.EKnowledgeAdapter(config);
-}
-function createVision(config) {
-    return isDisabled(config)
-        ? undefined
-        : new vision_1.OpenRouterVisionAdapter({ apiKey: process.env.OPENROUTER_API_KEY || '', model: config.model || 'gpt-4-vision' });
-}
-function createBehavior(config) {
-    return isDisabled(config) ? undefined : new behavior_1.ActiveSelfCompiler();
-}
-function createBody(config) {
-    return isDisabled(config)
-        ? undefined
-        : new body_1.Live2DAdapter(config);
-}
-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 = new memory_1.PostgresMemoryOrgan({ connectionString: process.env.DATABASE_URL || 'postgresql://postgres:postgres@localhost:5432/siduri' });
-    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);
-    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(PORT, () => {
-            console.log(`Siduri-Y API running on port ${PORT}`);
-        });
-    }).catch(e => {
-        console.error("Failed to boot default companion:", e);
-        process.exit(1);
-    });
-}

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -1,115 +0,0 @@
-"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', 'VIEWER', []);
-    });
-    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',
-                    audienceId: 'audience-public',
-                    correlationId: 'corr-route-1',
-                },
-            },
-            message: 'Hello structured context',
-            history: [],
-        });
-        expect(res.status).toBe(200);
-        expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith('Hello structured context', 'VIEWER', []);
-    });
-    test('rejects MASTER_PRIVATE in public request 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: false,
-                },
-                conversation: {
-                    channel: 'public',
-                    audienceId: 'MASTER_PRIVATE',
-                    correlationId: 'corr-err-1',
-                },
-            },
-            message: 'Forbidden audience test',
-        });
-        expect(res.status).toBe(400);
-        expect(res.body.accepted).toBe(false);
-        expect(res.body.error.code).toBe('LEGACY_PERSONAL_AUDIENCE');
-        expect(fakeRuntime.handleUserMessage).not.toHaveBeenCalled();
-    });
-    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',
-                    audienceId: 'audience-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();
-    });
-});

package/dist/runtime.d.ts

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

package/dist/runtime.js

@@ -1,17 +0,0 @@
-"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

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

package/dist/runtime.test.js

@@ -1,240 +0,0 @@
-"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 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("OWNER");
-        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',
-                audienceId: 'audience-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',
-                audienceId: 'audience-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/);
-    });
-});

package/dist/smoke.test.js

@@ -1,6 +0,0 @@
-"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

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