@siduri-x/api 1.0.2 → 1.0.5

package/dist/app.d.ts

@@ -0,0 +1,43 @@
+import { Express } from 'express';
+import { SiduriRuntime } from './runtime';
+import { VoiceConfig } from '@siduri-x/voice';
+import { EKnowledgeConfig } from '@siduri-x/knowledge';
+import { OpenRouterVisionConfig } from '@siduri-x/vision';
+import { Live2DAdapterConfig } from '@siduri-x/body';
+import { FixtureObservationOrgan } from '@siduri-x/observation';
+import { DefaultHandsOrganConfig } from '@siduri-x/hands';
+import { EarOrganConfig } from '@siduri-x/ear';
+import { DefaultMouthOrganConfig } from '@siduri-x/mouth';
+export interface AppBrainConfig {
+    provider?: 'openrouter' | 'openai-compatible' | string;
+    model?: string;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    [key: string]: unknown;
+}
+export interface AppBehaviorConfig {
+    provider?: 'active_self' | 'none' | string;
+    preset?: string;
+    [key: string]: unknown;
+}
+export interface AppBootCompanionConfig {
+    name: string;
+    brain?: AppBrainConfig;
+    voice?: VoiceConfig;
+    knowledge?: EKnowledgeConfig;
+    vision?: OpenRouterVisionConfig;
+    behavior?: AppBehaviorConfig;
+    body?: Live2DAdapterConfig;
+    hands?: DefaultHandsOrganConfig;
+    ear?: EarOrganConfig;
+    mouth?: DefaultMouthOrganConfig;
+    [key: string]: unknown;
+}
+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

@@ -0,0 +1,637 @@
+"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 mouth_1 = require("@siduri-x/mouth");
+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: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
+                speakerId: config?.speakerId || 1,
+                ...config,
+            });
+    }
+    function createKnowledge(config) {
+        return isDisabled(config) ? undefined : new knowledge_1.EKnowledgeAdapter(config || {});
+    }
+    function createVision(config) {
+        return isDisabled(config)
+            ? undefined
+            : new vision_1.OpenRouterVisionAdapter({
+                apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
+                model: config?.model || 'gpt-4-vision',
+                ...config,
+            });
+    }
+    function createBehavior(config) {
+        return isDisabled(config) ? undefined : new behavior_1.ActiveSelfCompiler();
+    }
+    function createBody(config) {
+        return isDisabled(config)
+            ? undefined
+            : new body_1.Live2DAdapter(config);
+    }
+    function 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);
+    }
+    function createMouth(config, voice) {
+        return isDisabled(config)
+            ? new mouth_1.DefaultMouthOrgan({ voice })
+            : new mouth_1.DefaultMouthOrgan({ ...config, voice });
+    }
+    app.post('/boot', auth_1.requireAuth, 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 mouth = createMouth(config.mouth, voice);
+            const runtime = new runtime_1.SiduriRuntime(id, config, {
+                brain,
+                memory,
+                voice,
+                knowledge,
+                vision,
+                behavior,
+                body,
+                hands,
+                ear,
+                mouth,
+                observation: observationOrgan,
+            });
+            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) => {
+        const connected = Boolean(observationOrgan) || Array.from(runtimes.values()).some((r) => Boolean(r.observation));
+        res.json({ connected });
+    });
+    app.get('/mouth/health', (req, res) => {
+        const hasMouth = Array.from(runtimes.values()).some((r) => Boolean(r.mouth));
+        res.json({ provider: "siduri-mouth", configured: hasMouth });
+    });
+    app.get('/mouth/channels', (req, res) => {
+        const id = req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime || !runtime.mouth || typeof runtime.mouth.getRegisteredChannels !== 'function') {
+            return res.json({ channels: [] });
+        }
+        res.json({ channels: runtime.mouth.getRegisteredChannels() });
+    });
+    app.get('/me', auth_1.attachIdentity, (req, res) => {
+        const identity = req.identity;
+        res.json({
+            actorId: identity.actorId || (identity.authenticated ? 'owner-user' : 'anonymous-session'),
+            role: identity.role || (identity.authenticated ? 'OWNER' : 'VIEWER'),
+            authenticated: Boolean(identity.authenticated),
+        });
+    });
+    app.put('/me', auth_1.requireAuth, (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: map request context directly
+        const mappingResult = (0, context_mapper_1.mapRequestContext)({
+            ...req.body,
+            id: id || req.body.companionId,
+            authenticated: identity?.authenticated ?? true,
+            source: identity?.source ?? 'local',
+            generateCorrelationId: true,
+        });
+        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,
+                ...(req.body?.medium ? { medium: req.body.medium } : {}),
+            });
+            res.json(response);
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // REAL-TIME SSE STREAMING (Mouth transport)
+    app.post('/chat/stream', auth_1.attachIdentity, async (req, res) => {
+        const { id, message, history } = req.body;
+        const identity = req.identity;
+        const mappingResult = (0, context_mapper_1.mapRequestContext)({
+            ...req.body,
+            id: id || req.body.companionId,
+            authenticated: identity?.authenticated ?? true,
+            source: identity?.source ?? 'local',
+            generateCorrelationId: true,
+        });
+        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" });
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache, no-transform');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders?.();
+        const abortController = new AbortController();
+        const onClose = () => {
+            abortController.abort('client_disconnect');
+            if (typeof runtime.interruptMouth === 'function') {
+                runtime.interruptMouth('client_disconnect');
+            }
+        };
+        req.on('close', onClose);
+        try {
+            const response = await (0, runtime_1.dispatchCompanionChat)(runtime, {
+                id: companionId,
+                companionId,
+                message,
+                context: mappingResult.context,
+                history,
+                medium: 'web',
+                signal: abortController.signal,
+            });
+            res.write(`event: staged\ndata: ${JSON.stringify({ response_id: response.response_id, correlation_id: response.correlation_id, status: response.status })}\n\n`);
+            const avatarEvent = response.metadata?.events?.find((e) => (e.kind === 'avatar' || e.kind === 'body') && (e.approval === 'APPROVED' || !e.approval));
+            if (avatarEvent) {
+                res.write(`event: avatar\ndata: ${JSON.stringify(avatarEvent)}\n\n`);
+            }
+            const speechText = response.delivery?.text || response.response?.subtitle_en || response.response?.spoken_ja || '';
+            const utterance = {
+                utteranceId: response.response_id || 'utt-stream',
+                companionId,
+                responseId: response.response_id,
+                correlationId: response.correlation_id,
+                text: speechText,
+                medium: 'web',
+                expression: avatarEvent?.expression,
+                action: avatarEvent?.action,
+                signal: abortController.signal,
+            };
+            if (runtime.mouth && typeof runtime.mouth.stream === 'function') {
+                for await (const chunk of runtime.mouth.stream(utterance)) {
+                    if (abortController.signal.aborted) {
+                        res.write(`event: chunk\ndata: ${JSON.stringify({ ...chunk, interrupted: true })}\n\n`);
+                        break;
+                    }
+                    res.write(`event: chunk\ndata: ${JSON.stringify(chunk)}\n\n`);
+                }
+            }
+            else {
+                res.write(`event: chunk\ndata: ${JSON.stringify({ utteranceId: utterance.utteranceId, index: 1, deltaText: speechText, isComplete: true, medium: 'web' })}\n\n`);
+            }
+            res.write(`event: done\ndata: ${JSON.stringify(response)}\n\n`);
+            res.end();
+        }
+        catch (e) {
+            if (abortController.signal.aborted) {
+                res.write(`event: interrupted\ndata: ${JSON.stringify({ reason: abortController.signal.reason })}\n\n`);
+            }
+            else {
+                res.write(`event: error\ndata: ${JSON.stringify({ error: e.message })}\n\n`);
+            }
+            res.end();
+        }
+        finally {
+            req.removeListener('close', onClose);
+        }
+    });
+    // INTERRUPTION / BARGE-IN
+    app.post('/chat/interrupt', auth_1.attachIdentity, (req, res) => {
+        const companionId = req.body?.companionId || req.body?.id || Array.from(runtimes.keys())[0];
+        const runtime = companionId ? runtimes.get(companionId) : undefined;
+        const reason = req.body?.reason || 'user_barge_in';
+        if (runtime) {
+            runtime.interruptMouth(reason);
+            return res.json({ success: true, interrupted: true, companionId, reason });
+        }
+        for (const r of runtimes.values()) {
+            r.interruptMouth(reason);
+        }
+        return res.json({ success: true, interrupted: true, reason });
+    });
+    app.post('/mouth/interrupt', auth_1.attachIdentity, (req, res) => {
+        const companionId = req.body?.companionId || req.body?.id || Array.from(runtimes.keys())[0];
+        const runtime = companionId ? runtimes.get(companionId) : undefined;
+        const reason = req.body?.reason || 'user_barge_in';
+        if (runtime) {
+            runtime.interruptMouth(reason);
+            return res.json({ success: true, interrupted: true, companionId, reason });
+        }
+        for (const r of runtimes.values()) {
+            r.interruptMouth(reason);
+        }
+        return res.json({ success: true, interrupted: true, reason });
+    });
+    // MEMORY GETTERS
+    app.get('/memory/proposals', auth_1.requireAuth, 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.getPendingClaims();
+            res.json({ proposals });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/memory', auth_1.requireAuth, 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.getClaims();
+            res.json({ items });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/memory/claims', auth_1.requireAuth, 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.getClaims();
+            res.json({ claims });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/memory/behavioral', auth_1.requireAuth, 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.getDirectives();
+            res.json({ directives });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // MEMORY MUTATIONS - PROPOSALS
+    app.post('/memory/proposals/update', auth_1.requireAuth, 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.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', auth_1.requireAuth, 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.approveClaim(req.body.id);
+            res.json({ approved: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/memory/proposals/reject', auth_1.requireAuth, 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.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', auth_1.requireAuth, 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.approveDirective(req.body.id);
+            res.json({ approved: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/memory/behavioral/reject', auth_1.requireAuth, 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.rejectDirective(req.body.id);
+            res.json({ rejected: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/memory/behavioral/revoke', auth_1.requireAuth, 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.revokeDirective(req.body.id);
+            res.json({ revoked: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/memory/behavioral/disable', auth_1.requireAuth, 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.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', auth_1.requireAuth, 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.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.stageResponse({
+                requestContext: {
+                    companionId,
+                    actor: {
+                        actorId: 'local-user',
+                        sessionId: 'sess-local',
+                        capabilities: ['chat', 'memory:approve'],
+                        authenticated: true,
+                    },
+                    conversation: {
+                        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.findStagedPlanByCorrelation(companionId, correlationId);
+                if (found) {
+                    responseId = found.responseId;
+                }
+            }
+            else if (responseId && !correlationId) {
+                const found = runtime.getStagedPlan(responseId);
+                if (found) {
+                    correlationId = found.correlationId;
+                }
+            }
+            if (!responseId) {
+                return res.status(400).json({ approved: false, error: 'UNKNOWN_APPROVAL_ID' });
+            }
+            const result = runtime.approveResponse({
+                responseId,
+                companionId,
+                correlationId: correlationId || '',
+            });
+            if (!result.success) {
+                return res.status(400).json({ approved: false, error: result.reason });
+            }
+            // Now evaluated as approved
+            const evaluation = runtime.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.findStagedPlanByCorrelation(companionId, correlationId);
+                if (found) {
+                    responseId = found.responseId;
+                }
+            }
+            else if (responseId && !correlationId) {
+                const found = runtime.getStagedPlan(responseId);
+                if (found) {
+                    correlationId = found.correlationId;
+                }
+            }
+            if (!responseId) {
+                return res.status(400).json({ rejected: false, error: 'UNKNOWN_APPROVAL_ID' });
+            }
+            const result = runtime.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) => {
+            const activeRuntime = Array.from(runtimes.values())[0];
+            const targetObs = activeRuntime?.observation || observationOrgan;
+            if (!targetObs)
+                return res.status(503).json({ accepted: false, reason: 'observation_unavailable' });
+            const result = await targetObs.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;
+            for (const r of runtimes.values()) {
+                r.observation = org;
+            }
+        },
+    };
+}