@siduri-x/api 1.0.1 → 1.0.2

package/src/index.ts

@@ -1,15 +1,15 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { Express } from 'express';
-import { createApp, AppInstance } from './app';
+import { createApp, AppInstance, AppBrainConfig, AppBehaviorConfig } from './app';
 import { SiduriRuntime } from './runtime';
 import { OpenAICompatibleBrain, OpenRouterBrain } from '@siduri-x/brain';
 import { PostgresMemoryOrgan } from '@siduri-x/memory';
-import { VoiceAdapter } from '@siduri-x/voice';
-import { EKnowledgeAdapter } from '@siduri-x/knowledge';
-import { OpenRouterVisionAdapter } from '@siduri-x/vision';
+import { VoiceAdapter, VoiceConfig } from '@siduri-x/voice';
+import { EKnowledgeAdapter, EKnowledgeConfig } from '@siduri-x/knowledge';
+import { OpenRouterVisionAdapter, OpenRouterVisionConfig } from '@siduri-x/vision';
 import { ActiveSelfCompiler } from '@siduri-x/behavior';
-import { Live2DAdapter } from '@siduri-x/body';
+import { Live2DAdapter, Live2DAdapterConfig } from '@siduri-x/body';
 import { FixtureObservationOrgan } from '@siduri-x/observation';
 
 export { createApp, AppInstance };
@@ -20,49 +20,58 @@ const instance: AppInstance = createApp(runtimes);
 export const app: Express = instance.app;
 export default app;
 
-function createBrain(config: any) {
-  const provider = config.provider || 'openrouter';
+function createBrain(config?: AppBrainConfig) {
+  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] || '';
+  const apiKey = config?.apiKey || process.env[config?.apiKeyEnv || defaultKeyEnv] || '';
   if (provider === 'openai-compatible') {
     return new OpenAICompatibleBrain({
       apiKey,
-      model: config.model || 'local-model',
-      baseUrl: config.baseUrl || 'http://127.0.0.1:1234/v1',
+      model: config?.model || 'local-model',
+      baseUrl: config?.baseUrl || 'http://127.0.0.1:1234/v1',
     });
   }
-  return new OpenRouterBrain({ apiKey, model: config.model || 'gpt-4o-mini' });
+  return new OpenRouterBrain({ apiKey, model: config?.model || 'gpt-4o-mini' });
 }
 
-function isDisabled(config: any): boolean {
+function isDisabled(config?: { provider?: string }): boolean {
   return !config || config.provider === 'none';
 }
 
-function createVoice(config: any) {
+function createVoice(config?: VoiceConfig) {
   return isDisabled(config)
     ? undefined
-    : new VoiceAdapter({ provider: config.provider || 'voicevox', baseUrl: process.env.VOICEVOX_URL || 'http://localhost:50021', speakerId: config.speakerId || 1 });
+    : new VoiceAdapter({
+        provider: (config?.provider as any) || 'voicevox',
+        baseUrl: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
+        speakerId: config?.speakerId || 1,
+        ...config,
+      });
 }
 
-function createKnowledge(config: any) {
+function createKnowledge(config?: EKnowledgeConfig) {
   if (isDisabled(config)) return undefined;
-  if (!config?.packPath && !config?.registryUrl && !config?.baseUrl && !config?.hubUrl) {
+  if (!config?.packPath && !config?.registryUrl && !config?.baseUrl) {
     return undefined;
   }
-  return new EKnowledgeAdapter(config);
+  return new EKnowledgeAdapter(config || {});
 }
 
-function createVision(config: any) {
+function createVision(config?: OpenRouterVisionConfig & { provider?: string }) {
   return isDisabled(config)
     ? undefined
-    : new OpenRouterVisionAdapter({ apiKey: process.env.OPENROUTER_API_KEY || '', model: config.model || 'gpt-4-vision' });
+    : new OpenRouterVisionAdapter({
+        apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
+        model: config?.model || 'gpt-4-vision',
+        ...config,
+      });
 }
 
-function createBehavior(config: any) {
+function createBehavior(config?: AppBehaviorConfig) {
   return isDisabled(config) ? undefined : new ActiveSelfCompiler();
 }
 
-function createBody(config: any) {
+function createBody(config?: Live2DAdapterConfig & { provider?: string }) {
   return isDisabled(config)
     ? undefined
     : new Live2DAdapter(config);

package/src/runtime.test.ts

@@ -1,6 +1,7 @@
-import { SiduriRuntime } from './runtime';
+import { SiduriRuntime, dispatchCompanionChat } from './runtime';
 import { DefaultHandsOrgan } from '@siduri-x/hands';
 import { DefaultEarOrgan } from '@siduri-x/ear';
+import { DefaultMouthOrgan } from '@siduri-x/mouth';
 import { ActionPolicyEngine, RequestContext } from '@siduri-x/core';
 
 describe('Siduri Runtime Orchestration', () => {
@@ -281,4 +282,57 @@ describe('Siduri Runtime Orchestration', () => {
       /Ear text input exceeds maximum allowed length/
     );
   });
+
+  test('Decoupled Output Delivery: Brain decisions are delivered and formatted through MouthOrgan', async () => {
+    let deliveredOutput: any = null;
+    const mouth = new DefaultMouthOrgan({
+      channels: [
+        {
+          id: 'test-web-channel',
+          name: 'Web Channel',
+          medium: 'web',
+          deliver: async (out) => {
+            deliveredOutput = out;
+          },
+        },
+      ],
+    });
+
+    const mockBrain = {
+      generatePlan: async () => ({
+        speech: '**Hello** from Siduri!',
+        language: 'en',
+      }),
+    };
+
+    const mockMemory = {
+      initialize: async () => {},
+      searchClaims: async () => [],
+      getDirectives: async () => [],
+    };
+
+    const runtime = new SiduriRuntime(
+      'companion-mouth-test',
+      { name: 'MouthCompanion' } as any,
+      {
+        brain: mockBrain as any,
+        memory: mockMemory as any,
+        mouth,
+      }
+    );
+    await runtime.initialize();
+
+    const response = await dispatchCompanionChat(runtime, {
+      message: 'Hi there',
+      role: 'OWNER',
+      medium: 'web',
+    });
+
+    expect(response.delivery).toBeDefined();
+    expect(response.delivery?.medium).toBe('web');
+    expect(response.delivery?.displayText).toBe('**Hello** from Siduri!');
+    expect(deliveredOutput).toBeDefined();
+    expect(deliveredOutput.medium).toBe('web');
+    expect(deliveredOutput.displayText).toBe('**Hello** from Siduri!');
+  });
 });

package/dist/app.d.ts

@@ -1,9 +0,0 @@
-import { Express } from 'express';
-import { SiduriRuntime } from './runtime';
-import { FixtureObservationOrgan } from '@siduri-x/observation';
-export interface AppInstance {
-    app: Express;
-    runtimes: Map<string, SiduriRuntime>;
-    setObservationOrgan: (org: FixtureObservationOrgan) => void;
-}
-export declare function createApp(runtimes?: Map<string, SiduriRuntime>): AppInstance;

package/dist/app.js

@@ -1,480 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createApp = createApp;
-const express_1 = __importDefault(require("express"));
-const cors_1 = __importDefault(require("cors"));
-const cors_2 = require("./cors");
-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 hands_1 = require("@siduri-x/hands");
-const ear_1 = require("@siduri-x/ear");
-const auth_1 = require("./auth");
-const context_mapper_1 = require("./context-mapper");
-function createApp(runtimes = new Map()) {
-    const app = (0, express_1.default)();
-    app.use((0, cors_1.default)((0, cors_2.createCorsOptions)()));
-    app.use(express_1.default.json());
-    let observationOrgan;
-    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: process.env.VOICEVOX_URL || 'http://localhost:50021', speakerId: config.speakerId || 1 });
-    }
-    function createKnowledge(config) {
-        return isDisabled(config) ? undefined : 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);
-    }
-    function createHands(config) {
-        return isDisabled(config)
-            ? new hands_1.DefaultHandsOrgan()
-            : new hands_1.DefaultHandsOrgan(config);
-    }
-    function createEar(config) {
-        return isDisabled(config)
-            ? new ear_1.DefaultEarOrgan()
-            : new ear_1.DefaultEarOrgan(config);
-    }
-    app.post('/boot', (0, auth_1.requireRole)(['OWNER']), async (req, res) => {
-        try {
-            const { id, config } = req.body;
-            if (runtimes.has(id)) {
-                return res.status(400).json({ error: "Already booted" });
-            }
-            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 behavior = createBehavior(config.behavior);
-            const body = createBody(config.body);
-            const hands = createHands(config.hands);
-            const ear = createEar(config.ear);
-            const runtime = new runtime_1.SiduriRuntime(id, config, { brain, memory, voice, knowledge, vision, behavior, body, hands, ear });
-            await runtime.initialize();
-            runtimes.set(id, runtime);
-            res.json({ success: true, id });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    // STATUS / HEALTH ENDPOINTS
-    app.get('/health', (req, res) => res.json({ status: "ok" }));
-    app.get('/version', (req, res) => res.json({ name: "siduri-x-api", version: "0.2.0-x" }));
-    app.get('/ready', (req, res) => {
-        const isReady = runtimes.size > 0;
-        res.status(isReady ? 200 : 503).json({
-            status: isReady ? "ready" : "not_ready",
-            companionCount: runtimes.size,
-        });
-    });
-    app.get('/voice/health', (req, res) => {
-        const hasVoice = Array.from(runtimes.values()).some((r) => Boolean(r.voice));
-        res.json({ provider: "siduri-voice", configured: hasVoice });
-    });
-    app.get('/obs/health', (req, res) => res.json({ connected: Boolean(observationOrgan) }));
-    app.get('/me', auth_1.attachIdentity, (req, res) => {
-        const identity = req.identity;
-        res.json({
-            actorId: identity.role === 'OWNER' ? 'owner-user' : 'anonymous-session',
-            role: identity.role,
-            authenticated: identity.role === 'OWNER',
-        });
-    });
-    app.put('/me', (0, auth_1.requireRole)(['OWNER']), (req, res) => res.json({ success: true }));
-    // CHAT (API context boundary validation)
-    app.post('/chat', auth_1.attachIdentity, async (req, res) => {
-        const { id, message, history } = req.body;
-        const identity = req.identity;
-        // Single-owner companion model: /chat defaults to OWNER identity.
-        // Explicit non-owner role in request body or context (e.g. adversarial test suites) is respected.
-        const effectiveRole = req.body?.role === 'VIEWER' || req.body?.context?.actor?.authorizationRole === 'viewer'
-            ? 'VIEWER'
-            : (identity?.role === 'OPERATOR' ? 'OPERATOR' : 'OWNER');
-        const isOwner = effectiveRole === 'OWNER';
-        // Call context mapper at the API boundary
-        const mappingResult = (0, context_mapper_1.mapRequestContext)({
-            ...req.body,
-            id: id || req.body.companionId,
-            role: effectiveRole,
-            authenticated: isOwner,
-            generateCorrelationId: true,
-        }, {
-            endpointPolicy: 'public',
-            defaultPublicAudience: 'audience-public',
-        });
-        if (!mappingResult.accepted) {
-            return res.status(400).json({
-                accepted: false,
-                error: mappingResult.error,
-            });
-        }
-        const companionId = mappingResult.context.companionId;
-        const runtime = runtimes.get(companionId);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        try {
-            const response = await (0, runtime_1.dispatchCompanionChat)(runtime, {
-                id: companionId,
-                companionId,
-                message,
-                context: mappingResult.context,
-                history,
-            });
-            res.json(response);
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    // MEMORY GETTERS
-    app.get('/memory/proposals', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.query.id || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.json({ proposals: [] });
-        try {
-            const proposals = await runtime.memory.getPendingClaims();
-            res.json({ proposals });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.get('/memory', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.query.id || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.json({ items: [] });
-        try {
-            const items = await runtime.memory.getClaims();
-            res.json({ items });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.get('/memory/claims', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.query.id || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.json({ claims: [] });
-        try {
-            const claims = await runtime.memory.getClaims();
-            res.json({ claims });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.get('/memory/behavioral', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.query.id || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.json({ directives: [] });
-        try {
-            const directives = await runtime.memory.getDirectives();
-            res.json({ directives });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    // MEMORY MUTATIONS - PROPOSALS
-    app.post('/memory/proposals/update', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory || typeof runtime.memory.updateClaim !== 'function') {
-            return res.status(400).json({ error: "Memory organ does not support updating claims" });
-        }
-        try {
-            const claimId = req.body.id || req.body.claimId;
-            if (!claimId) {
-                return res.status(400).json({ error: "Missing required claim id" });
-            }
-            const updated = await runtime.memory.updateClaim(claimId, req.body.updates || req.body);
-            res.json({ success: true, claim: updated });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.post('/memory/proposals/approve', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.status(400).json({ error: "Memory organ not configured" });
-        try {
-            await runtime.memory.approveClaim(req.body.id);
-            res.json({ approved: true });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.post('/memory/proposals/reject', (0, auth_1.requireRole)(['OWNER', 'OPERATOR']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.status(400).json({ error: "Memory organ not configured" });
-        try {
-            await runtime.memory.rejectClaim(req.body.id);
-            res.json({ rejected: true });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    // MEMORY MUTATIONS - BEHAVIORAL
-    app.post('/memory/behavioral/approve', (0, auth_1.requireRole)(['OWNER']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.status(400).json({ error: "Memory organ not configured" });
-        try {
-            await runtime.memory.approveDirective(req.body.id);
-            res.json({ approved: true });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.post('/memory/behavioral/reject', (0, auth_1.requireRole)(['OWNER']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.status(400).json({ error: "Memory organ not configured" });
-        try {
-            await runtime.memory.rejectDirective(req.body.id);
-            res.json({ rejected: true });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.post('/memory/behavioral/revoke', (0, auth_1.requireRole)(['OWNER']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.status(400).json({ error: "Memory organ not configured" });
-        try {
-            await runtime.memory.revokeDirective(req.body.id);
-            res.json({ revoked: true });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    app.post('/memory/behavioral/disable', (0, auth_1.requireRole)(['OWNER']), async (req, res) => {
-        const id = req.body.companionId || Array.from(runtimes.keys())[0];
-        const runtime = runtimes.get(id);
-        if (!runtime)
-            return res.status(404).json({ error: "Companion not found" });
-        if (!runtime.memory)
-            return res.status(400).json({ error: "Memory organ not configured" });
-        try {
-            await runtime.memory.disableDirective(req.body.id);
-            res.json({ disabled: true });
-        }
-        catch (e) {
-            res.status(500).json({ error: e.message });
-        }
-    });
-    const isDevMode = process.env.NODE_ENV !== 'production' || process.env.SIDURI_DEV_MODE === 'true';
-    if (isDevMode) {
-        app.post('/dev/memory/reset', (0, auth_1.requireRole)(['OWNER']), async (req, res) => {
-            const id = req.body.companionId || Array.from(runtimes.keys())[0];
-            const runtime = runtimes.get(id);
-            if (!runtime)
-                return res.status(404).json({ error: "Companion not found" });
-            if (!runtime.memory || typeof runtime.memory.resetMemory !== 'function') {
-                return res.status(400).json({ error: "Memory organ does not support reset" });
-            }
-            try {
-                await runtime.memory.resetMemory();
-                res.json({ reset: true });
-            }
-            catch (e) {
-                res.status(500).json({ error: e.message });
-            }
-        });
-        app.post('/dev/mock-response', async (req, res) => {
-            const companionId = req.body?.companionId || Array.from(runtimes.keys())[0] || 'default';
-            const runtime = runtimes.get(companionId);
-            if (!runtime)
-                return res.status(404).json({ accepted: false, error: 'Companion not found' });
-            const staged = runtime.gating.stageResponse({
-                requestContext: {
-                    companionId,
-                    actor: {
-                        actorId: 'operator-a',
-                        sessionId: 'sess-op',
-                        authorizationRole: 'operator',
-                        capabilities: ['chat:public', 'memory:approve'],
-                        authenticated: true,
-                    },
-                    conversation: {
-                        channel: 'public',
-                        audienceId: 'audience-public',
-                        correlationId: req.body?.correlation_id || `corr-${Date.now()}`,
-                    },
-                },
-                candidateSpeech: req.body?.speech || 'Mocked staged response for review',
-                candidateLanguage: req.body?.language || 'en',
-                requiresApproval: req.body?.requiresApproval ?? true,
-            });
-            res.json({
-                accepted: true,
-                staged: true,
-                status: staged.status,
-                response_id: staged.responseId,
-                correlation_id: staged.correlationId,
-                speech: staged.speech,
-            });
-        });
-        app.post('/dev/approve-response', async (req, res) => {
-            const companionId = req.body?.companionId || Array.from(runtimes.keys())[0] || 'default';
-            const runtime = runtimes.get(companionId);
-            if (!runtime)
-                return res.status(404).json({ approved: false, error: 'Companion not found' });
-            let responseId = req.body?.responseId;
-            let correlationId = req.body?.correlation_id;
-            if (!responseId && correlationId) {
-                const found = runtime.gating.findStagedPlanByCorrelation(companionId, correlationId);
-                if (found) {
-                    responseId = found.responseId;
-                }
-            }
-            else if (responseId && !correlationId) {
-                const found = runtime.gating.getStagedPlan(responseId);
-                if (found) {
-                    correlationId = found.correlationId;
-                }
-            }
-            if (!responseId) {
-                return res.status(400).json({ approved: false, error: 'UNKNOWN_APPROVAL_ID' });
-            }
-            const result = runtime.gating.approveResponse({
-                responseId,
-                companionId,
-                correlationId: correlationId || '',
-                audienceId: req.body?.audienceId,
-            });
-            if (!result.success) {
-                return res.status(400).json({ approved: false, error: result.reason });
-            }
-            // Now evaluated as approved
-            const evaluation = runtime.gating.evaluateGate(result.plan);
-            res.json({
-                approved: true,
-                status: evaluation.disposition,
-                response_id: result.plan.responseId,
-                speech: result.plan.speech,
-                language: result.plan.language,
-            });
-        });
-        app.post('/dev/reject-response', async (req, res) => {
-            const companionId = req.body?.companionId || Array.from(runtimes.keys())[0] || 'default';
-            const runtime = runtimes.get(companionId);
-            if (!runtime)
-                return res.status(404).json({ rejected: false, error: 'Companion not found' });
-            let responseId = req.body?.responseId;
-            let correlationId = req.body?.correlation_id;
-            if (!responseId && correlationId) {
-                const found = runtime.gating.findStagedPlanByCorrelation(companionId, correlationId);
-                if (found) {
-                    responseId = found.responseId;
-                }
-            }
-            else if (responseId && !correlationId) {
-                const found = runtime.gating.getStagedPlan(responseId);
-                if (found) {
-                    correlationId = found.correlationId;
-                }
-            }
-            if (!responseId) {
-                return res.status(400).json({ rejected: false, error: 'UNKNOWN_APPROVAL_ID' });
-            }
-            const result = runtime.gating.rejectResponse({
-                responseId,
-                companionId,
-                correlationId: correlationId || '',
-                reason: req.body?.reason,
-            });
-            if (!result.success) {
-                return res.status(400).json({ rejected: false, error: result.reason });
-            }
-            res.json({
-                rejected: true,
-                status: result.plan.status,
-                response_id: result.plan.responseId,
-            });
-        });
-        app.post('/dev/mock-observation', async (req, res) => {
-            if (!observationOrgan)
-                return res.status(503).json({ accepted: false, reason: 'observation_unavailable' });
-            const result = await observationOrgan.ingest(new Uint8Array([115, 121, 110, 116, 104, 101, 116, 105, 99]), 'fixture-observation', 'configured-vision');
-            if (!result.observation)
-                return res.status(result.duplicate ? 200 : 409).json({ accepted: false, ...result });
-            res.status(202).json({ accepted: true, observation: result.observation });
-        });
-    }
-    return { app, runtimes, setObservationOrgan: (org) => { observationOrgan = org; } };
-}

package/dist/auth.d.ts

@@ -1,8 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-export type Role = 'OWNER' | 'OPERATOR' | 'VIEWER';
-export interface Identity {
-    role: Role;
-}
-export declare function resolveIdentity(req: Request): Identity;
-export declare function requireRole(allowedRoles: Role[]): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;
-export declare function attachIdentity(req: Request, res: Response, next: NextFunction): void;