@siduri-x/core 1.0.8 → 1.0.9

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export * from './action-executor';
 export * from './experience-emitter';
 export * from './response-envelope';
 export * from './session-history';
+export * from './schema-validator';
 import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
 import { RequestContext } from './context';

package/dist/index.js

@@ -39,5 +39,6 @@ __exportStar(require("./action-executor"), exports);
 __exportStar(require("./experience-emitter"), exports);
 __exportStar(require("./response-envelope"), exports);
 __exportStar(require("./session-history"), exports);
+__exportStar(require("./schema-validator"), exports);
 // Mouth (Communication & Output Delivery)
 __exportStar(require("./mouth-types"), exports);

package/dist/runtime-facades.test.js

@@ -66,4 +66,30 @@ describe('SiduriRuntime Facade Methods & Delegation', () => {
         await runtime.resetMemory();
         expect(mockMemory.resetMemory).toHaveBeenCalled();
     });
+    test('configures SqliteActionStore when actionStore is sqlite', () => {
+        const runtime = new runtime_1.SiduriRuntime('comp-sqlite', {
+            id: 'comp-sqlite',
+            name: 'Sqlite Test',
+            actionStore: 'sqlite',
+        });
+        expect(runtime.actionPolicy.getStore()).toBeDefined();
+        // Verify it is an instance of SqliteActionStore
+        expect(runtime.actionPolicy.getStore().constructor.name).toBe('SqliteActionStore');
+    });
+    test('accepts custom actionStore via RuntimeOrgans', () => {
+        const customStore = {
+            recordExecution: jest.fn(),
+            getExecution: jest.fn(),
+            updateExecution: jest.fn(),
+            recordApproval: jest.fn(),
+            getApproval: jest.fn(),
+            recordAudit: jest.fn(),
+            getAuditLog: jest.fn(),
+            verifyAuditChain: jest.fn(),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-custom', { id: 'comp-custom', name: 'Custom' }, {
+            actionStore: customStore,
+        });
+        expect(runtime.actionPolicy.getStore()).toBe(customStore);
+    });
 });

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ActionStore, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
 export interface SiduriRuntimeConfig {
     name: string;
     brain?: OrganConfig | Record<string, unknown>;
@@ -13,6 +13,11 @@ export interface SiduriRuntimeConfig {
     observation?: OrganConfig | Record<string, unknown>;
     mouth?: OrganConfig | Record<string, unknown>;
     actionPolicy?: Record<string, unknown>;
+    actionStore?: 'in-memory' | 'sqlite' | {
+        type: 'sqlite' | 'in-memory';
+        dbPath?: string;
+    };
+    actionStorePath?: string;
     [key: string]: unknown;
 }
 export interface RuntimeOrgans {
@@ -27,6 +32,7 @@ export interface RuntimeOrgans {
     ear?: EarOrgan;
     observation?: ObservationOrgan;
     mouth?: MouthOrgan;
+    actionStore?: ActionStore;
     actionPolicy?: ActionPolicyEngine;
 }
 export interface CompanionPerception {

package/dist/runtime.js

@@ -57,7 +57,17 @@ class SiduriRuntime {
         this.observation = organs.observation;
         this.mouth = organs.mouth;
         this.gating = new index_1.ResponseGatingEngine();
-        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine();
+        let actionStore = organs.actionStore;
+        if (!actionStore) {
+            const storeOpt = config.actionStore;
+            const storePath = config.actionStorePath || (typeof storeOpt === 'object' ? storeOpt.dbPath : undefined);
+            if (storeOpt === 'sqlite' || (typeof storeOpt === 'object' && storeOpt.type === 'sqlite') || storePath) {
+                actionStore = new index_1.SqliteActionStore({ dbPath: storePath });
+            }
+        }
+        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine({
+            store: actionStore,
+        });
         this.dispatcher = new index_1.ExperienceDispatcher();
         if (this.voice && typeof this.voice.handleEvent === 'function') {
             this.dispatcher.registerAdapter(this.voice);

package/dist/schema-validator.d.ts

@@ -0,0 +1,9 @@
+export declare class ConfigValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+/**
+ * Validates a companion configuration object against a JSON schema (draft-07 compatible).
+ * Throws ConfigValidationError if validation errors are detected.
+ */
+export declare function validateCompanionConfig(config: unknown, schema: any, path?: string): void;

package/dist/schema-validator.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidationError = void 0;
+exports.validateCompanionConfig = validateCompanionConfig;
+class ConfigValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Siduri configuration validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+        this.name = 'ConfigValidationError';
+        this.errors = errors;
+    }
+}
+exports.ConfigValidationError = ConfigValidationError;
+/**
+ * Validates a companion configuration object against a JSON schema (draft-07 compatible).
+ * Throws ConfigValidationError if validation errors are detected.
+ */
+function validateCompanionConfig(config, schema, path = '$') {
+    const errors = [];
+    function validateNode(value, nodeSchema, curPath) {
+        if (!nodeSchema || typeof nodeSchema !== 'object')
+            return;
+        // Type validation
+        if (nodeSchema.type !== undefined) {
+            const type = nodeSchema.type;
+            if (type === 'object') {
+                if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                    errors.push(`${curPath}: expected object, received ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'array') {
+                if (!Array.isArray(value)) {
+                    errors.push(`${curPath}: expected array, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'string') {
+                if (typeof value !== 'string') {
+                    errors.push(`${curPath}: expected string, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'number') {
+                if (typeof value !== 'number' || Number.isNaN(value)) {
+                    errors.push(`${curPath}: expected number, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'integer') {
+                if (typeof value !== 'number' || !Number.isInteger(value)) {
+                    errors.push(`${curPath}: expected integer, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'boolean') {
+                if (typeof value !== 'boolean') {
+                    errors.push(`${curPath}: expected boolean, received ${typeof value}`);
+                    return;
+                }
+            }
+        }
+        // Enum validation
+        if (Array.isArray(nodeSchema.enum)) {
+            if (!nodeSchema.enum.includes(value)) {
+                errors.push(`${curPath}: invalid value ${JSON.stringify(value)}, expected one of: ${nodeSchema.enum.map((v) => JSON.stringify(v)).join(', ')}`);
+                return;
+            }
+        }
+        // Object properties validation
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            if (Array.isArray(nodeSchema.required)) {
+                for (const reqKey of nodeSchema.required) {
+                    if (value[reqKey] === undefined) {
+                        errors.push(`${curPath}.${reqKey}: is required`);
+                    }
+                }
+            }
+            const definedProps = nodeSchema.properties || {};
+            if (nodeSchema.additionalProperties === false) {
+                for (const key of Object.keys(value)) {
+                    // Allow $schema property at root level
+                    if (curPath === '$' && key === '$schema')
+                        continue;
+                    if (!(key in definedProps)) {
+                        errors.push(`${curPath}.${key}: unexpected property is not allowed`);
+                    }
+                }
+            }
+            for (const [propName, propSchema] of Object.entries(definedProps)) {
+                if (value[propName] !== undefined) {
+                    validateNode(value[propName], propSchema, `${curPath}.${propName}`);
+                }
+            }
+        }
+        // Array items validation
+        if (Array.isArray(value) && nodeSchema.items) {
+            value.forEach((item, index) => {
+                validateNode(item, nodeSchema.items, `${curPath}[${index}]`);
+            });
+        }
+    }
+    validateNode(config, schema, path);
+    if (errors.length > 0) {
+        throw new ConfigValidationError(errors);
+    }
+}

package/dist/schema-validator.test.d.ts

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

package/dist/schema-validator.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_validator_1 = require("./schema-validator");
+describe('validateCompanionConfig', () => {
+    const sampleSchema = {
+        type: 'object',
+        required: ['id', 'name', 'organs'],
+        additionalProperties: false,
+        properties: {
+            $schema: { type: 'string' },
+            id: { type: 'string' },
+            name: { type: 'string' },
+            organs: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    brain: {
+                        type: 'object',
+                        required: ['provider', 'model'],
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                enum: ['openrouter', 'openai-compatible'],
+                            },
+                            model: { type: 'string' },
+                        },
+                    },
+                    memory: {
+                        type: 'object',
+                        required: ['provider'],
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                enum: ['postgres', 'in-memory', 'none'],
+                            },
+                            maxConnections: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    test('accepts valid configuration matching schema', () => {
+        const validConfig = {
+            $schema: './siduri.schema.json',
+            id: 'companion-1',
+            name: 'Test Companion',
+            organs: {
+                brain: {
+                    provider: 'openrouter',
+                    model: 'gpt-4o',
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(validConfig, sampleSchema)).not.toThrow();
+    });
+    test('throws ConfigValidationError if missing required root field', () => {
+        const invalidConfig = {
+            name: 'Missing Id and Organs',
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.id: is required');
+            expect(err.errors).toContain('$.organs: is required');
+        }
+    });
+    test('throws ConfigValidationError on unexpected property when additionalProperties is false', () => {
+        const invalidConfig = {
+            id: 'c-1',
+            name: 'Test',
+            organs: {},
+            extraField: 'not allowed',
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.extraField: unexpected property is not allowed');
+        }
+    });
+    test('throws ConfigValidationError on invalid enum value', () => {
+        const invalidConfig = {
+            id: 'c-1',
+            name: 'Test',
+            organs: {
+                brain: {
+                    provider: 'invalid-brain-provider',
+                    model: 'gpt-4',
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors.some((e) => e.includes('invalid value "invalid-brain-provider"'))).toBe(true);
+        }
+    });
+    test('throws ConfigValidationError on invalid type', () => {
+        const invalidConfig = {
+            id: 12345, // should be string
+            name: 'Test',
+            organs: {
+                memory: {
+                    provider: 'postgres',
+                    maxConnections: 'ten', // should be number
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.id: expected string, received number');
+            expect(err.errors).toContain('$.organs.memory.maxConnections: expected number, received string');
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/core",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Core runtime types, evidence protocol, action dispatcher, capability validation, and SiduriRuntime protocol",
   "license": "Apache-2.0",
   "repository": {