@vxnus/siduri 0.0.7 → 0.0.8

package/dist/clean-machine-e2e.test.js

@@ -24,7 +24,7 @@ describe('Phase 5: Clean-Machine Distribution & E2E Integration Suite', () => {
         { filter: '@siduri-x/body', tarName: 'siduri-x-body-1.0.0.tgz', isOrgan: true },
         { filter: '@siduri-x/voice', tarName: 'siduri-x-voice-1.0.0.tgz', isOrgan: true },
         { filter: '@siduri-x/observation', tarName: 'siduri-x-observation-1.0.0.tgz', isOrgan: true },
-        { filter: '@vxnus/siduri', tarName: 'vxnus-siduri-0.0.7.tgz', isOrgan: false },
+        { filter: '@vxnus/siduri', tarName: 'vxnus-siduri-0.0.8.tgz', isOrgan: false },
     ];
     beforeAll(() => {
         // 1. Prepare clean directories

package/dist/configurators/behavior.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureBehavior(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/behavior.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureBehavior = configureBehavior;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureBehavior(_context) {
+    const { preset } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'preset',
+        message: 'Personality projection preset:',
+        choices: [
+            { name: 'Calm & Precise (Default)', value: 'calm_precise' },
+            { name: 'Cheerful & Enthusiastic', value: 'cheerful' },
+            { name: 'Analytical & Methodical', value: 'analytical' },
+            { name: 'Custom Directive State Machine', value: 'custom' },
+        ],
+    });
+    const presetLabels = {
+        calm_precise: 'Calm & Precise',
+        cheerful: 'Cheerful & Enthusiastic',
+        analytical: 'Analytical & Methodical',
+        custom: 'Custom Directives',
+    };
+    return {
+        config: {
+            provider: 'active_self',
+            preset,
+        },
+        summary: {
+            Provider: 'Active Self Directives',
+            Preset: presetLabels[preset] || preset,
+        },
+    };
+}

package/dist/configurators/body.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureBody(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/body.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureBody = configureBody;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureBody(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Body avatar provider?',
+        choices: [
+            { name: 'Live2D Cubism (Interactive avatar motion & expression state)', value: 'live2d' },
+            { name: 'None (Headless / No visual body)', value: 'none' },
+        ],
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Headless)' },
+        };
+    }
+    const { initialExpression } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'initialExpression',
+        message: 'Initial avatar expression:',
+        choices: [
+            { name: 'Neutral', value: 'neutral' },
+            { name: 'Happy / Cheerful', value: 'happy' },
+            { name: 'Calm', value: 'calm' },
+        ],
+    });
+    return {
+        config: {
+            provider: 'live2d',
+            initialExpression,
+        },
+        summary: {
+            Provider: 'Live2D',
+            Expression: initialExpression,
+        },
+    };
+}

package/dist/configurators/brain.d.ts

@@ -0,0 +1,6 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+import { ModelProvider } from '../providers/openrouter';
+export interface BrainConfiguratorOptions {
+    modelProvider?: ModelProvider;
+}
+export declare function configureBrain(_context: OrganConfiguratorContext, options?: BrainConfiguratorOptions): Promise<OrganConfigurationResult>;

package/dist/configurators/brain.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureBrain = configureBrain;
+const inquirer_1 = __importDefault(require("inquirer"));
+const openrouter_1 = require("../providers/openrouter");
+async function configureBrain(_context, options = {}) {
+    const modelProvider = options.modelProvider || new openrouter_1.OpenRouterModelProvider();
+    while (true) {
+        const { provider } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'provider',
+            message: 'Brain provider?',
+            choices: [
+                { name: 'OpenRouter (Managed Routing & Broad Model Access)', value: 'openrouter' },
+                { name: 'OpenAI-compatible / Custom endpoint (Ollama, vLLM, Azure, OpenAI)', value: 'openai-compatible' },
+            ],
+        });
+        if (provider === 'openrouter') {
+            const selection = await (0, openrouter_1.promptOpenRouterModelSelection)(modelProvider);
+            if (selection.type === 'switch_provider') {
+                continue;
+            }
+            if (selection.type === 'cancel') {
+                throw new Error('Brain configuration cancelled.');
+            }
+            const modelId = selection.modelId;
+            return {
+                config: {
+                    provider: 'openrouter',
+                    model: modelId,
+                    apiKeyEnv: 'OPENROUTER_API_KEY',
+                },
+                summary: {
+                    Provider: 'OpenRouter',
+                    Model: modelId,
+                },
+            };
+        }
+        if (provider === 'openai-compatible') {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'Endpoint Base URL:',
+                    default: 'https://api.openai.com/v1',
+                    validate: (v) => v.trim().length > 0 || 'Base URL is required.',
+                },
+                {
+                    type: 'input',
+                    name: 'model',
+                    message: 'Model ID (e.g. gpt-4o, llama3, mistral):',
+                    default: 'gpt-4o',
+                    validate: (v) => v.trim().length > 0 || 'Model ID is required.',
+                },
+                {
+                    type: 'input',
+                    name: 'apiKeyEnv',
+                    message: 'API Key environment variable name:',
+                    default: 'OPENAI_COMPATIBLE_API_KEY',
+                },
+            ]);
+            return {
+                config: {
+                    provider: 'openai-compatible',
+                    model: answers.model.trim(),
+                    baseUrl: answers.baseUrl.trim(),
+                    apiKeyEnv: answers.apiKeyEnv.trim() || 'OPENAI_COMPATIBLE_API_KEY',
+                },
+                summary: {
+                    Provider: 'OpenAI-compatible',
+                    Model: answers.model.trim(),
+                    'Base URL': answers.baseUrl.trim(),
+                },
+            };
+        }
+    }
+}

package/dist/configurators/ear.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureEar(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/ear.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureEar = configureEar;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureEar(_context) {
+    const { defaultSource } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'defaultSource',
+        message: 'Perception ingress channel:',
+        choices: [
+            { name: 'Text Chat (Standard multimodal chat ingress)', value: 'text_chat' },
+            { name: 'Audio Streaming Ingress', value: 'audio_stream' },
+        ],
+    });
+    return {
+        config: {
+            defaultSource,
+            maxTextLength: 4000,
+            maxAudioBytes: 10485760,
+        },
+        summary: {
+            'Default Ingress': defaultSource === 'text_chat' ? 'Text Chat' : 'Audio Stream',
+        },
+    };
+}

package/dist/configurators/hands.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureHands(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/hands.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureHands = configureHands;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureHands(_context) {
+    const { timeoutSeconds } = await inquirer_1.default.prompt({
+        type: 'input',
+        name: 'timeoutSeconds',
+        message: 'MCP Tool execution timeout (seconds):',
+        default: '10',
+        validate: (v) => (!isNaN(Number(v)) && Number(v) > 0) || 'Timeout must be a positive number.',
+    });
+    const timeoutMs = Math.round(Number(timeoutSeconds) * 1000);
+    return {
+        config: {
+            defaultTimeoutMs: timeoutMs,
+            providers: [],
+        },
+        summary: {
+            'Default Timeout': `${timeoutSeconds}s`,
+            'MCP Execution': 'Active Policy HMAC Protected',
+        },
+    };
+}

package/dist/configurators/index.d.ts

@@ -0,0 +1,23 @@
+import { OrganManifest } from '../manifest';
+import { OrganConfigurationResult } from './types';
+import { BrainConfiguratorOptions } from './brain';
+import { KnowledgeConfiguratorOptions } from './knowledge';
+export * from './types';
+export * from './brain';
+export * from './knowledge';
+export * from './memory';
+export * from './voice';
+export * from './body';
+export * from './hands';
+export * from './behavior';
+export * from './vision';
+export * from './ear';
+export * from './observation';
+export interface ConfigureOrganOptions {
+    brainOptions?: BrainConfiguratorOptions;
+    knowledgeOptions?: KnowledgeConfiguratorOptions;
+}
+export declare function configureOrgan(manifest: OrganManifest, context: {
+    companionName: string;
+    existingConfig?: Record<string, unknown>;
+}, options?: ConfigureOrganOptions): Promise<OrganConfigurationResult>;

package/dist/configurators/index.js

@@ -0,0 +1,74 @@
+"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 });
+exports.configureOrgan = configureOrgan;
+const brain_1 = require("./brain");
+const knowledge_1 = require("./knowledge");
+const memory_1 = require("./memory");
+const voice_1 = require("./voice");
+const body_1 = require("./body");
+const hands_1 = require("./hands");
+const behavior_1 = require("./behavior");
+const vision_1 = require("./vision");
+const ear_1 = require("./ear");
+const observation_1 = require("./observation");
+__exportStar(require("./types"), exports);
+__exportStar(require("./brain"), exports);
+__exportStar(require("./knowledge"), exports);
+__exportStar(require("./memory"), exports);
+__exportStar(require("./voice"), exports);
+__exportStar(require("./body"), exports);
+__exportStar(require("./hands"), exports);
+__exportStar(require("./behavior"), exports);
+__exportStar(require("./vision"), exports);
+__exportStar(require("./ear"), exports);
+__exportStar(require("./observation"), exports);
+async function configureOrgan(manifest, context, options = {}) {
+    const ctx = {
+        companionName: context.companionName,
+        manifest,
+        existingConfig: context.existingConfig,
+    };
+    switch (manifest.organType) {
+        case 'brain':
+            return (0, brain_1.configureBrain)(ctx, options.brainOptions);
+        case 'knowledge':
+            return (0, knowledge_1.configureKnowledge)(ctx, options.knowledgeOptions);
+        case 'memory':
+            return (0, memory_1.configureMemory)(ctx);
+        case 'voice':
+            return (0, voice_1.configureVoice)(ctx);
+        case 'body':
+            return (0, body_1.configureBody)(ctx);
+        case 'hands':
+            return (0, hands_1.configureHands)(ctx);
+        case 'behavior':
+            return (0, behavior_1.configureBehavior)(ctx);
+        case 'vision':
+            return (0, vision_1.configureVision)(ctx);
+        case 'ear':
+            return (0, ear_1.configureEar)(ctx);
+        case 'observation':
+            return (0, observation_1.configureObservation)(ctx);
+        default:
+            return {
+                config: ctx.existingConfig || {},
+                summary: {
+                    Provider: manifest.displayName,
+                },
+            };
+    }
+}

package/dist/configurators/knowledge.d.ts

@@ -0,0 +1,6 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+import { KnowledgeHubClient } from '../providers/knowledge-hub';
+export interface KnowledgeConfiguratorOptions {
+    client?: KnowledgeHubClient;
+}
+export declare function configureKnowledge(_context: OrganConfiguratorContext, options?: KnowledgeConfiguratorOptions): Promise<OrganConfigurationResult>;

package/dist/configurators/knowledge.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureKnowledge = configureKnowledge;
+const inquirer_1 = __importDefault(require("inquirer"));
+const knowledge_hub_1 = require("../providers/knowledge-hub");
+async function configureKnowledge(_context, options = {}) {
+    const client = options.client || new knowledge_hub_1.KnowledgeHubClient();
+    const { source } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'source',
+        message: 'Knowledge source?',
+        choices: [
+            { name: 'E Knowledge Hub (Search and attach remote factual pack)', value: 'e-hub' },
+            { name: 'Do not use knowledge', value: 'none' },
+        ],
+    });
+    if (source === 'none') {
+        return {
+            config: {
+                provider: 'none',
+            },
+            summary: {
+                Source: 'Do not use knowledge',
+            },
+        };
+    }
+    // E Knowledge Hub flow
+    while (true) {
+        const { packId } = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'packId',
+            message: 'Search E Knowledge Hub or enter package ID:',
+            default: '@vxnus/e-teyvat',
+            validate: (val) => val.trim().length > 0 || 'Please enter a package ID.',
+        });
+        const trimmedPackId = packId.trim();
+        let manifest;
+        try {
+            process.stdout.write('\u001b[2mSearching E Knowledge Hub...\u001b[0m');
+            manifest = await client.resolveProvider(trimmedPackId);
+            process.stdout.write('\r\u001b[32m✓\u001b[0m Checking provider manifest\n');
+        }
+        catch (err) {
+            process.stdout.write('\r\u001b[33m!\u001b[0m Provider resolution failed\n');
+            console.log(`\u001b[33mReason:\u001b[0m ${err.message}\n`);
+            const { failureAction } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'failureAction',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Try again / Search another provider', value: 'retry' },
+                    { name: 'Do not use knowledge', value: 'skip' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+            });
+            if (failureAction === 'retry') {
+                continue;
+            }
+            if (failureAction === 'skip') {
+                return {
+                    config: { provider: 'none' },
+                    summary: { Source: 'Do not use knowledge' },
+                };
+            }
+            throw new Error('Knowledge configuration cancelled.');
+        }
+        // Display provider summary
+        (0, knowledge_hub_1.displayKnowledgeProviderSummary)(manifest, trimmedPackId);
+        const { confirmProvider } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'confirmProvider',
+            message: 'Use this knowledge provider?',
+            choices: [
+                { name: 'Yes, use this provider', value: 'yes' },
+                { name: 'Choose another provider', value: 'retry' },
+            ],
+        });
+        if (confirmProvider === 'yes') {
+            return {
+                config: {
+                    provider: 'e-hub',
+                    registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge',
+                    packId: trimmedPackId,
+                },
+                summary: {
+                    Source: 'E Knowledge Hub',
+                    Provider: manifest.displayName || manifest.name,
+                    Package: trimmedPackId,
+                    Version: manifest.version,
+                },
+                metadata: {
+                    manifest,
+                },
+            };
+        }
+    }
+}

package/dist/configurators/memory.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureMemory(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/memory.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureMemory = configureMemory;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureMemory(_context) {
+    const { database } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'database',
+        message: 'Memory database?',
+        choices: [
+            { name: 'PostgreSQL (FTS relational claims with ACID durability)', value: 'postgres' },
+        ],
+    });
+    const { deployment } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'deployment',
+        message: 'PostgreSQL deployment target?',
+        choices: [
+            { name: 'Supabase (Hosted Postgres with connection pooling)', value: 'supabase' },
+            { name: 'Neon (Serverless Postgres with branch-per-companion)', value: 'neon' },
+            { name: 'Local PostgreSQL (Docker or system service)', value: 'local' },
+            { name: 'Other PostgreSQL URL', value: 'other' },
+        ],
+    });
+    const deploymentDisplayNames = {
+        supabase: 'Supabase',
+        neon: 'Neon',
+        local: 'Local PostgreSQL',
+        other: 'Other PostgreSQL',
+    };
+    return {
+        config: {
+            provider: database,
+            deployment,
+        },
+        summary: {
+            Database: 'PostgreSQL',
+            Deploy: deploymentDisplayNames[deployment] || deployment,
+        },
+    };
+}

package/dist/configurators/observation.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureObservation(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/observation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureObservation = configureObservation;
+async function configureObservation(_context) {
+    return {
+        config: {},
+        summary: {
+            Provider: 'Grounded Observation Ingest',
+            Deduplication: 'Cryptographic SHA-256 Hashing',
+        },
+    };
+}

package/dist/configurators/types.d.ts

@@ -0,0 +1,12 @@
+import { OrganManifest } from '../manifest';
+export interface OrganConfigurationResult {
+    config: Record<string, unknown>;
+    summary?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface OrganConfiguratorContext {
+    companionName: string;
+    manifest: OrganManifest;
+    existingConfig?: Record<string, unknown>;
+}
+export type OrganConfigurator = (context: OrganConfiguratorContext) => Promise<OrganConfigurationResult>;

package/dist/configurators/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/configurators/vision.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureVision(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/vision.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureVision = configureVision;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureVision(_context) {
+    const { model } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'model',
+        message: 'Vision model:',
+        choices: [
+            { name: 'GPT-4 Vision / GPT-4o (Multimodal OCR & Object Inspection)', value: 'gpt-4-vision' },
+            { name: 'Claude 3.5 Sonnet Vision', value: 'anthropic/claude-3.5-sonnet' },
+            { name: 'Custom Vision Model', value: 'custom' },
+        ],
+    });
+    let selectedModel = model;
+    if (model === 'custom') {
+        const { customModel } = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'customModel',
+            message: 'Vision Model ID:',
+            default: 'gpt-4-vision',
+        });
+        selectedModel = customModel.trim();
+    }
+    return {
+        config: {
+            provider: 'openrouter',
+            model: selectedModel,
+        },
+        summary: {
+            Provider: 'OpenRouter Vision',
+            Model: selectedModel,
+        },
+    };
+}

package/dist/configurators/voice.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureVoice(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/voice.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureVoice = configureVoice;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureVoice(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Voice provider?',
+        choices: [
+            { name: 'VOICEVOX (Local high-fidelity neural speech synthesis engine)', value: 'voicevox' },
+            { name: 'None (Disable voice synthesis)', value: 'none' },
+        ],
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Voice disabled)' },
+        };
+    }
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'baseUrl',
+            message: 'VOICEVOX Engine Base URL:',
+            default: 'http://localhost:50021',
+        },
+        {
+            type: 'input',
+            name: 'speakerId',
+            message: 'Default Speaker ID (e.g. 1 for Zundamon, 2 for Shikoku Metan):',
+            default: '1',
+            validate: (v) => !isNaN(parseInt(v, 10)) || 'Speaker ID must be an integer.',
+        },
+    ]);
+    const speakerId = parseInt(answers.speakerId, 10) || 1;
+    return {
+        config: {
+            provider: 'voicevox',
+            baseUrl: answers.baseUrl.trim(),
+            speakerId,
+            maxQueueDepth: 50,
+        },
+        summary: {
+            Provider: 'VOICEVOX',
+            'Speaker ID': speakerId,
+            'Base URL': answers.baseUrl.trim(),
+        },
+    };
+}

package/dist/configurators.test.d.ts

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