@siduri-x/api 1.0.5 → 2.0.2

package/src/b0-b6.test.ts

@@ -43,7 +43,7 @@ describe('T0 B0 & B6 Runtime Proof Suite', () => {
     const config = {
       name: 'NeutralCompanion',
       brain: { provider: 'openrouter' },
-      memory: { provider: 'postgres' },
+      memory: { provider: 'sqlite' },
       knowledge: { provider: 'e-knowledge' },
       behavior: { provider: 'active-self' },
       voice: { provider: 'none' },

package/src/boot.test.ts

@@ -0,0 +1,103 @@
+import { bootCompanion, isDisabled, createBrain, createMemory, createVoice, createKnowledge, createVision, createBehavior, createBody, createHands, createEar, createMouth, createSelf, createObservation } from './boot';
+import { FixtureObservationOrgan } from '@siduri-x/observation';
+
+describe('Canonical bootCompanion & Organ Factory Suite', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  test('isDisabled correctly identifies undefined or none provider', () => {
+    expect(isDisabled(undefined)).toBe(true);
+    expect(isDisabled({ provider: 'none' })).toBe(true);
+    expect(isDisabled({ provider: 'openrouter' })).toBe(false);
+    expect(isDisabled({ provider: 'sqlite' })).toBe(false);
+  });
+
+  test('creates all standard organs with fallback configurations', () => {
+    const brain = createBrain({ provider: 'openai-compatible', baseUrl: 'http://localhost:11434/v1', apiKey: 'test' });
+    expect(brain).toBeDefined();
+
+    const voice = createVoice({ provider: 'none' });
+    expect(voice).toBeUndefined();
+
+    const memory = createMemory({ provider: 'sqlite', dbPath: ':memory:' });
+    expect(memory).toBeDefined();
+
+    const selfRepo = createSelf({ dbPath: ':memory:' });
+    expect(selfRepo).toBeDefined();
+
+    const vision = createVision({ provider: 'none' });
+    expect(vision).toBeUndefined();
+
+    const behavior = createBehavior({ provider: 'active_self' });
+    expect(behavior).toBeDefined();
+
+    const body = createBody({ provider: 'none' });
+    expect(body).toBeUndefined();
+
+    const hands = createHands();
+    expect(hands).toBeDefined();
+
+    const ear = createEar();
+    expect(ear).toBeDefined();
+
+    const mouth = createMouth(undefined, voice);
+    expect(mouth).toBeDefined();
+
+    const observation = createObservation();
+    expect(observation).toBeInstanceOf(FixtureObservationOrgan);
+  });
+
+  test('bootCompanion wires all organs and runs migrations', async () => {
+    let migrationsRun = false;
+    const testConfig = {
+      name: 'Test Companion',
+      brain: { provider: 'openrouter', apiKey: 'mock-key', model: 'mock-model' },
+      memory: { provider: 'none' }, // will use custom mock
+      voice: { provider: 'none' },
+      vision: { provider: 'none' },
+      behavior: { provider: 'none' },
+      body: { provider: 'none' },
+      hands: { provider: 'none' },
+      ear: { provider: 'none' },
+      mouth: { provider: 'none' },
+      knowledge: { provider: 'none' },
+    };
+
+    const mockObservation = new FixtureObservationOrgan({ analyze: async () => JSON.stringify({ readings: [] }) });
+
+    const runtime = await bootCompanion('test-comp-1', testConfig as any, {
+      observationOrgan: mockObservation,
+    });
+
+    expect(runtime).toBeDefined();
+    expect(runtime.id).toBe('test-comp-1');
+    expect(runtime.observation).toBe(mockObservation);
+    expect(runtime.hands).toBeDefined();
+    expect(runtime.ear).toBeDefined();
+    expect(runtime.mouth).toBeDefined();
+  });
+
+  test('bootCompanion handles nested organs configuration structure', async () => {
+    const nestedConfig = {
+      name: 'Nested Companion',
+      organs: {
+        brain: { provider: 'openrouter', apiKey: 'mock' },
+        memory: { provider: 'none' },
+        knowledge: { provider: 'none' },
+        voice: { provider: 'none' },
+      },
+    };
+
+    const runtime = await bootCompanion('nested-comp', nestedConfig as any);
+    expect(runtime).toBeDefined();
+    expect(runtime.id).toBe('nested-comp');
+    expect(runtime.brain).toBeDefined();
+  });
+});

package/src/boot.ts

@@ -0,0 +1,190 @@
+import { OpenAICompatibleBrain, OpenRouterBrain } from '@siduri-x/brain';
+import { SqliteMemoryStore } from '@siduri-x/memory';
+import { VoiceAdapter, VoiceConfig } from '@siduri-x/voice';
+import { UnifiedKnowledgeOrgan, UnifiedKnowledgeConfig } from '@siduri-x/knowledge';
+import { OpenRouterVisionAdapter, OpenRouterVisionConfig } from '@siduri-x/vision';
+import { ActiveSelfCompiler, SqliteSelfRepository } from '@siduri-x/self';
+import { Live2DAdapter, Live2DAdapterConfig } from '@siduri-x/body';
+import { FixtureObservationOrgan } from '@siduri-x/observation';
+import { DefaultHandsOrgan, DefaultHandsOrganConfig } from '@siduri-x/hands';
+import { DefaultEarOrgan, EarOrganConfig } from '@siduri-x/ear';
+import { DefaultMouthOrgan, DefaultMouthOrganConfig } from '@siduri-x/mouth';
+import { SiduriRuntime } from './runtime';
+
+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;
+  id?: string;
+  brain?: AppBrainConfig;
+  voice?: VoiceConfig;
+  memory?: { provider?: string; connectionString?: string; maxConnections?: number; dbPath?: string; [key: string]: unknown };
+  knowledge?: UnifiedKnowledgeConfig;
+  vision?: OpenRouterVisionConfig;
+  behavior?: AppBehaviorConfig;
+  body?: Live2DAdapterConfig;
+  hands?: DefaultHandsOrganConfig;
+  ear?: EarOrganConfig;
+  mouth?: DefaultMouthOrganConfig;
+  self?: { dbPath?: string; [key: string]: unknown };
+  organs?: Record<string, any>;
+  [key: string]: unknown;
+}
+
+export interface BootCompanionOptions {
+  observationOrgan?: FixtureObservationOrgan;
+}
+
+export function isDisabled(config?: { provider?: string }): boolean {
+  return !config || config.provider === 'none';
+}
+
+export 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] || '';
+  if (provider === 'openai-compatible') {
+    return new OpenAICompatibleBrain({
+      apiKey,
+      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' });
+}
+
+export function createVoice(config?: VoiceConfig) {
+  return isDisabled(config)
+    ? undefined
+    : new VoiceAdapter({
+        provider: (config?.provider as any) || 'voicevox',
+        baseUrl: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
+        speakerId: config?.speakerId || 1,
+        ...config,
+      });
+}
+
+export function createKnowledge(config?: UnifiedKnowledgeConfig) {
+  if (isDisabled(config)) return undefined;
+  const dbPath = (config?.dbPath as string) || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite';
+  return new UnifiedKnowledgeOrgan({
+    ...config,
+    dbPath,
+    lifeDatabase: config?.lifeDatabase ?? true,
+  });
+}
+
+export function createVision(config?: OpenRouterVisionConfig & { provider?: string }) {
+  return isDisabled(config)
+    ? undefined
+    : new OpenRouterVisionAdapter({
+        apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
+        model: config?.model || 'gpt-4-vision',
+        ...config,
+      });
+}
+
+export function createBehavior(config?: AppBehaviorConfig) {
+  return isDisabled(config) ? undefined : new ActiveSelfCompiler();
+}
+
+export function createBody(config?: Live2DAdapterConfig & { provider?: string }) {
+  return isDisabled(config)
+    ? undefined
+    : new Live2DAdapter(config);
+}
+
+export function createHands(config?: DefaultHandsOrganConfig & { provider?: string }) {
+  return isDisabled(config)
+    ? new DefaultHandsOrgan()
+    : new DefaultHandsOrgan(config);
+}
+
+export function createEar(config?: EarOrganConfig & { provider?: string }) {
+  return isDisabled(config)
+    ? new DefaultEarOrgan()
+    : new DefaultEarOrgan(config);
+}
+
+export function createMouth(config?: DefaultMouthOrganConfig & { provider?: string }, voice?: any) {
+  return isDisabled(config)
+    ? new DefaultMouthOrgan({ voice })
+    : new DefaultMouthOrgan({ ...config, voice });
+}
+
+export function createMemory(config?: { provider?: string; connectionString?: string; maxConnections?: number; dbPath?: string }) {
+  if (isDisabled(config)) return undefined;
+  return new SqliteMemoryStore({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+}
+
+export function createSelf(config?: { dbPath?: string }) {
+  return new SqliteSelfRepository({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+}
+
+export function createObservation(vision?: any): FixtureObservationOrgan {
+  return new FixtureObservationOrgan(
+    vision ?? { analyze: async () => JSON.stringify({ readings: [] }) }
+  );
+}
+
+/**
+ * Canonical companion bootstrapper.
+ * Wires all 10 organs, runs memory migrations, and initializes the SiduriRuntime.
+ */
+export async function bootCompanion(
+  id: string,
+  config: AppBootCompanionConfig,
+  options?: BootCompanionOptions
+): Promise<SiduriRuntime> {
+  const organs = (config as any)?.organs || {};
+
+  const brain = createBrain(organs.brain || config?.brain);
+  const memory = createMemory(organs.memory || (config as any)?.memory);
+  const selfRepo = createSelf(organs.self || (config as any)?.self);
+  const voice = createVoice(organs.voice || config?.voice);
+  const knowledge = createKnowledge(organs.knowledge || config?.knowledge);
+  const vision = createVision(organs.vision || config?.vision);
+  const behavior = createBehavior(organs.behavior || config?.behavior);
+  const body = createBody(organs.body || config?.body);
+  const hands = createHands(organs.hands || config?.hands);
+  const ear = createEar(organs.ear || config?.ear);
+  const mouth = createMouth(organs.mouth || config?.mouth, voice);
+  const observation = options?.observationOrgan;
+
+  if (memory && typeof (memory as any).runMigrations === 'function') {
+    await (memory as any).runMigrations().catch((e: any) => console.warn("Migrations warning:", e.message));
+  }
+
+  const runtime = new SiduriRuntime(id, config as any, {
+    brain,
+    memory,
+    voice,
+    knowledge,
+    vision,
+    behavior,
+    body,
+    hands,
+    ear,
+    mouth,
+    observation,
+    self: selfRepo,
+    externalKnowledge: (knowledge as any)?.eAdapter ?? knowledge,
+  });
+
+  await runtime.initialize();
+  return runtime;
+}

package/src/context-mapper.test.ts

@@ -150,4 +150,131 @@ describe('API Request Context Mapper (Single-Owner, Single-Machine)', () => {
     expect(result.accepted).toBe(true);
     expect(result.context?.conversation.correlationId).toMatch(/^corr-/);
   });
+
+  test('Overrides forged client actor authentication and caps capabilities on unauthenticated requests', () => {
+    const forgedInput = {
+      companionId: 'companion-a',
+      authenticated: false, // Server detected unauthenticated request
+      source: 'external',
+      context: {
+        actor: {
+          actorId: 'attacker',
+          sessionId: 'session-att',
+          authenticated: true, // Forged
+          capabilities: ['system:exec', 'bash', 'chat'], // Forged elevated capabilities
+          authorizationRole: 'OWNER', // Forged role
+        },
+        conversation: {
+          correlationId: 'corr-forged-1',
+        },
+      },
+    };
+
+    const result = mapRequestContext(forgedInput);
+    expect(result.accepted).toBe(true);
+    expect(result.context?.actor.authenticated).toBe(false);
+    expect(result.context?.actor.capabilities).toEqual(['chat']);
+    expect(result.context?.actor.authorizationRole).toBe('viewer');
+    expect(result.context?.source).toBe('external');
+    expect(result.diagnostics).toContain('role_escalation_attempt_suppressed');
+    expect(result.diagnostics).toContain('capability_escalation_attempt_suppressed');
+  });
+
+  test('Prevents attenuated caller from escalating to administrator role or forging elevated capabilities', () => {
+    const attenuatedPayload = {
+      companionId: 'companion-a',
+      authenticated: true,
+      role: 'VIEWER',
+      source: 'external',
+      context: {
+        actor: {
+          actorId: 'visitor-bob',
+          sessionId: 'session-vis-1',
+          authorizationRole: 'administrator', // Forged owner/admin role
+          capabilities: ['chat', 'system', 'root:manage', 'action:execute'], // Forged system/root capabilities
+        },
+        conversation: {
+          correlationId: 'corr-att-escalate',
+        },
+      },
+    };
+
+    const result = mapRequestContext(attenuatedPayload);
+    expect(result.accepted).toBe(true);
+    expect(result.context?.actor.authenticated).toBe(true);
+    expect(result.context?.actor.authorizationRole).toBe('viewer');
+    expect(result.context?.actor.capabilities).toEqual(['chat']);
+    expect(result.diagnostics).toContain('role_escalation_attempt_suppressed');
+    expect(result.diagnostics).toContain('capability_escalation_attempt_suppressed');
+  });
+
+  test('Strips unknown capabilities for authenticated owner while preserving canonical companion capabilities', () => {
+    const ownerPayload = {
+      companionId: 'companion-a',
+      authenticated: true,
+      source: 'local',
+      context: {
+        actor: {
+          actorId: 'owner-user',
+          sessionId: 'session-owner-1',
+          capabilities: ['chat', 'system', 'root:unauthorized', 'arbitrary:hack'],
+        },
+        conversation: {
+          correlationId: 'corr-owner-caps',
+        },
+      },
+    };
+
+    const result = mapRequestContext(ownerPayload);
+    expect(result.accepted).toBe(true);
+    expect(result.context?.actor.authorizationRole).toBe('administrator');
+    expect(result.context?.actor.capabilities).toEqual(['chat', 'system']);
+    expect(result.diagnostics).toContain('capability_escalation_attempt_suppressed');
+  });
+
+  test('Flat envelope: suppresses role and capability escalation when serverRole is VIEWER', () => {
+    const viewerPayload = {
+      companionId: 'companion-a',
+      authenticated: false,
+      serverRole: 'VIEWER',
+      role: 'OWNER', // Forged in flat envelope
+      capabilities: ['chat', 'system', 'action:execute'],
+      generateCorrelationId: true,
+    };
+
+    const result = mapRequestContext(viewerPayload);
+    expect(result.accepted).toBe(true);
+    expect(result.context?.actor.authorizationRole).toBe('viewer');
+    expect(result.context?.actor.capabilities).toEqual(['chat']);
+    expect(result.diagnostics).toContain('role_escalation_attempt_suppressed');
+  });
+
+  test('Authenticated owner receives canonical administrator role and capabilities, and can safely attenuate to viewer', () => {
+    const ownerPayload = {
+      companionId: 'companion-a',
+      authenticated: true,
+      serverRole: 'OWNER',
+      generateCorrelationId: true,
+    };
+
+    const ownerResult = mapRequestContext(ownerPayload);
+    expect(ownerResult.accepted).toBe(true);
+    expect(ownerResult.context?.actor.authorizationRole).toBe('administrator');
+    expect(ownerResult.context?.actor.capabilities).toEqual([
+      'chat',
+      'memory:approve',
+      'action:execute',
+      'system',
+    ]);
+
+    // Attenuation to viewer
+    const attenuatedPayload = {
+      ...ownerPayload,
+      role: 'VIEWER',
+    };
+    const attenuatedResult = mapRequestContext(attenuatedPayload);
+    expect(attenuatedResult.accepted).toBe(true);
+    expect(attenuatedResult.context?.actor.authorizationRole).toBe('viewer');
+    expect(attenuatedResult.diagnostics).not.toContain('role_escalation_attempt_suppressed');
+  });
 });

package/src/context-mapper.ts

@@ -20,8 +20,10 @@ export interface MapRequestContextResult {
 /**
  * Maps incoming HTTP requests to a canonical RequestContext.
  * In a single-owner, single-machine model:
- * - Security is enforced at the external boundary, not internally between roles.
+ * - Security is enforced at the external machine boundary, NOT internally between roles.
  * - No internal audience or viewer/operator/owner role hierarchies.
+ * - Authenticated callers are the single owner with full companion access.
+ * - Unauthenticated callers are bounded to public chat.
  */
 export function mapRequestContext(
   input: any,
@@ -43,7 +45,10 @@ export function mapRequestContext(
   if (input.context && typeof input.context === 'object') {
     const rawCtx = input.context;
     const companionId = input.companionId || rawCtx.companionId || input.id;
-    const correlationId = rawCtx.conversation?.correlationId || input.correlationId;
+    const correlationId =
+      rawCtx.conversation?.correlationId ||
+      input.correlationId ||
+      (input.generateCorrelationId ? `corr-${Date.now()}` : undefined);
 
     if (!companionId) {
       return {
@@ -81,15 +86,56 @@ export function mapRequestContext(
       };
     }
 
+    const isViewerRequested =
+      (typeof input.role === 'string' && input.role.toLowerCase() === 'viewer') ||
+      (typeof input.serverRole === 'string' && input.serverRole.toLowerCase() === 'viewer') ||
+      (typeof actor.authorizationRole === 'string' && actor.authorizationRole.toLowerCase() === 'viewer') ||
+      (typeof (actor as any).role === 'string' && (actor as any).role.toLowerCase() === 'viewer');
+
+    // Determine server-enforced authentication status at the machine boundary
+    const isAuthenticated = input.authenticated !== undefined
+      ? Boolean(input.authenticated)
+      : (actor.authenticated !== undefined ? Boolean(actor.authenticated) : true);
+
+    const isViewer = !isAuthenticated || isViewerRequested;
+
+    const CANONICAL_CAPABILITIES = new Set(['chat', 'memory:approve', 'action:execute', 'system']);
+    const DEFAULT_OWNER_CAPABILITIES = ['chat', 'memory:approve', 'action:execute', 'system'];
+
+    let safeCapabilities: string[];
+    let authorizationRole: string;
+
+    if (isViewer) {
+      safeCapabilities = ['chat'];
+      authorizationRole = 'viewer';
+      if (Array.isArray(actor.capabilities) && actor.capabilities.some((c: string) => c !== 'chat' && c !== 'chat:public')) {
+        diagnostics.push('capability_escalation_attempt_suppressed');
+      }
+      if (actor.authorizationRole && actor.authorizationRole.toLowerCase() !== 'viewer') {
+        diagnostics.push('role_escalation_attempt_suppressed');
+      }
+    } else {
+      authorizationRole = 'administrator';
+      if (Array.isArray(actor.capabilities) && actor.capabilities.length > 0) {
+        const filtered = actor.capabilities.filter((c: string) => CANONICAL_CAPABILITIES.has(c));
+        if (filtered.length < actor.capabilities.length) {
+          diagnostics.push('capability_escalation_attempt_suppressed');
+        }
+        safeCapabilities = filtered.length > 0 ? filtered : [...DEFAULT_OWNER_CAPABILITIES];
+      } else {
+        safeCapabilities = [...DEFAULT_OWNER_CAPABILITIES];
+      }
+    }
+
     const constructed: RequestContext = {
       companionId,
       actor: {
+        ...actor,
         actorId: actor.actorId,
         sessionId: actor.sessionId,
-        capabilities: Array.isArray(actor.capabilities) ? actor.capabilities : ['chat'],
-        authenticated: actor.authenticated !== undefined ? Boolean(actor.authenticated) : true,
-        authorizationRole: actor.authorizationRole,
-        ...actor,
+        capabilities: safeCapabilities,
+        authenticated: isAuthenticated,
+        authorizationRole,
       },
       conversation: {
         correlationId,
@@ -97,7 +143,7 @@ export function mapRequestContext(
         isLive: rawCtx.conversation?.isLive,
         ...rawCtx.conversation,
       },
-      source: input.source || rawCtx.source || 'local',
+      source: input.source || rawCtx.source || (isAuthenticated ? 'local' : 'external'),
       subject: rawCtx.subject,
     };
 
@@ -154,17 +200,52 @@ export function mapRequestContext(
     };
   }
 
-  const actorId = input.actorId || input.actor?.actorId || 'local-user';
+  const isViewerRequested =
+    (typeof input.role === 'string' && input.role.toLowerCase() === 'viewer') ||
+    (typeof input.serverRole === 'string' && input.serverRole.toLowerCase() === 'viewer');
+
+  const isAuthenticated = input.authenticated !== undefined ? Boolean(input.authenticated) : true;
+  const isViewer = !isAuthenticated || isViewerRequested;
+
+  const actorId = input.actorId || input.actor?.actorId || (isAuthenticated && !isViewer ? 'local-user' : 'anonymous-session');
   const sessionId = input.sessionId || input.actor?.sessionId || `session-${Date.now()}`;
   if (!input.actorId && !input.actor?.actorId) {
     diagnostics.push('anonymous_session_generated');
   }
 
-  const capabilities = Array.isArray(input.capabilities)
+  const CANONICAL_CAPABILITIES = new Set(['chat', 'memory:approve', 'action:execute', 'system']);
+  const DEFAULT_OWNER_CAPABILITIES = ['chat', 'memory:approve', 'action:execute', 'system'];
+
+  const rawCaps = Array.isArray(input.capabilities)
     ? input.capabilities
     : Array.isArray(input.actor?.capabilities)
     ? input.actor.capabilities
-    : ['chat', 'system'];
+    : undefined;
+
+  let capabilities: string[];
+  let authorizationRole: string;
+
+  if (isViewer) {
+    capabilities = ['chat'];
+    authorizationRole = 'viewer';
+    if (rawCaps && rawCaps.some((c: string) => c !== 'chat' && c !== 'chat:public')) {
+      diagnostics.push('capability_escalation_attempt_suppressed');
+    }
+    if (input.role && input.role.toLowerCase() !== 'viewer') {
+      diagnostics.push('role_escalation_attempt_suppressed');
+    }
+  } else {
+    authorizationRole = 'administrator';
+    if (rawCaps && rawCaps.length > 0) {
+      const filtered = rawCaps.filter((c: string) => CANONICAL_CAPABILITIES.has(c));
+      if (filtered.length < rawCaps.length) {
+        diagnostics.push('capability_escalation_attempt_suppressed');
+      }
+      capabilities = filtered.length > 0 ? filtered : [...DEFAULT_OWNER_CAPABILITIES];
+    } else {
+      capabilities = [...DEFAULT_OWNER_CAPABILITIES];
+    }
+  }
 
   const mappedContext: RequestContext = {
     companionId,
@@ -172,14 +253,14 @@ export function mapRequestContext(
       actorId,
       sessionId,
       capabilities,
-      authenticated: input.authenticated !== undefined ? Boolean(input.authenticated) : true,
-      authorizationRole: input.role ? (input.role.toLowerCase() === 'viewer' ? 'viewer' : 'administrator') : undefined,
+      authenticated: isAuthenticated,
+      authorizationRole,
     },
     conversation: {
       channel: input.channel || input.conversation?.channel || 'direct',
       correlationId,
     },
-    source: input.source || 'local',
+    source: input.source || (isAuthenticated ? 'local' : 'external'),
     subject: input.subject,
   };
 

package/src/index.test.ts

@@ -127,7 +127,7 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
   });
 
   test('handles barge-in interruption via POST /chat/interrupt', async () => {
-    fakeRuntime.interruptMouth = jest.fn();
+    fakeRuntime.mouth = { interrupt: jest.fn() };
 
     const res = await request(app)
       .post('/chat/interrupt')
@@ -138,11 +138,11 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
 
     expect(res.status).toBe(200);
     expect(res.body.interrupted).toBe(true);
-    expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_stop');
+    expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_stop');
   });
 
   test('handles mouth interruption via POST /mouth/interrupt', async () => {
-    fakeRuntime.interruptMouth = jest.fn();
+    fakeRuntime.mouth = { interrupt: jest.fn() };
 
     const res = await request(app)
       .post('/mouth/interrupt')
@@ -153,6 +153,6 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
 
     expect(res.status).toBe(200);
     expect(res.body.interrupted).toBe(true);
-    expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_barge_in');
+    expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_barge_in');
   });
 });