@siduri-x/api 1.0.1 → 1.0.4

package/src/context-mapper.ts

@@ -1,17 +1,12 @@
 import {
   RequestContext,
-  AuthorizationRole,
-  Channel,
   DiagnosticCode,
   ContextError,
   validateRequestContext,
 } from '@siduri-x/core';
 
 export interface ContextMapperOptions {
-  endpointPolicy?: 'public' | 'private' | 'operator' | 'direct';
-  defaultPublicAudience?: string;
-  defaultPrivateAudience?: string;
-  defaultOperatorAudience?: string;
+  endpointPolicy?: 'public' | 'private' | 'operator' | 'direct' | string;
   allowAnonymousPublicChat?: boolean;
 }
 
@@ -22,13 +17,17 @@ export interface MapRequestContextResult {
   error?: ContextError;
 }
 
+/**
+ * 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.
+ * - No internal audience or viewer/operator/owner role hierarchies.
+ */
 export function mapRequestContext(
   input: any,
   options: ContextMapperOptions = {}
 ): MapRequestContextResult {
   const diagnostics: DiagnosticCode[] = [];
-  const endpointPolicy = options.endpointPolicy || 'public';
-  const defaultPublicAudience = options.defaultPublicAudience || 'audience-public';
 
   if (!input || typeof input !== 'object') {
     return {
@@ -40,27 +39,7 @@ export function mapRequestContext(
     };
   }
 
-  // Check for legacy MASTER_PRIVATE in any audience field or request
-  const rawAudience =
-    input?.context?.conversation?.audienceId ??
-    input?.conversation?.audienceId ??
-    input?.audienceId ??
-    input?.audience;
-
-  if (rawAudience === 'MASTER_PRIVATE' || input?.scope === 'MASTER_PRIVATE') {
-    if (endpointPolicy === 'public' || input?.channel === 'public' || input?.context?.conversation?.channel === 'public') {
-      return {
-        accepted: false,
-        error: {
-          code: 'LEGACY_PERSONAL_AUDIENCE',
-          field: 'audienceId',
-          correlationId: input?.context?.conversation?.correlationId || input?.correlationId,
-        },
-      };
-    }
-  }
-
-  // 1. If incoming input already has a full neutral context structure
+  // 1. If incoming input already has a context structure
   if (input.context && typeof input.context === 'object') {
     const rawCtx = input.context;
     const companionId = input.companionId || rawCtx.companionId || input.id;
@@ -77,48 +56,6 @@ export function mapRequestContext(
       };
     }
 
-    // Role cannot select audience or subject
-    const rawRole = input.role || rawCtx.actor?.authorizationRole;
-    if (input.role && !rawCtx.conversation?.channel && !rawCtx.conversation?.audienceId) {
-      return {
-        accepted: false,
-        error: {
-          code: 'AMBIGUOUS_CONTEXT',
-          conflicts: ['role_does_not_select_audience', 'role_does_not_select_subject'],
-          correlationId,
-        },
-      };
-    }
-
-    const channel: Channel = rawCtx.conversation?.channel || (endpointPolicy as Channel);
-    let audienceId: string | undefined = rawCtx.conversation?.audienceId;
-
-    if (!audienceId) {
-      if (channel === 'public' || endpointPolicy === 'public') {
-        audienceId = defaultPublicAudience;
-        diagnostics.push('audience_defaulted_by_public_policy');
-      } else {
-        return {
-          accepted: false,
-          error: {
-            code: 'MISSING_CONTEXT',
-            fields: ['conversation.audienceId'],
-            correlationId,
-          },
-        };
-      }
-    }
-
-    if (!correlationId) {
-      return {
-        accepted: false,
-        error: {
-          code: 'MISSING_CONTEXT',
-          fields: ['conversation.correlationId'],
-        },
-      };
-    }
-
     const actor = rawCtx.actor;
     if (!actor || typeof actor !== 'object') {
       return {
@@ -131,64 +68,37 @@ export function mapRequestContext(
       };
     }
 
-    // Check required capabilities for private/operator/direct channels
-    const capabilities: string[] = Array.isArray(actor.capabilities) ? actor.capabilities : [];
-    if (channel === 'private' && !capabilities.includes('chat:private')) {
-      return {
-        accepted: false,
-        error: {
-          code: 'UNAUTHORIZED_CHANNEL_OR_CAPABILITY',
-          message: 'Private channel requires explicit chat:private capability',
-          fields: ['actor.capabilities'],
-          correlationId,
-        },
-      };
-    }
-    if (channel === 'operator' && !capabilities.includes('memory:inspect') && !capabilities.includes('operator:access')) {
+    // Reject invalid primary_user subject
+    if (rawCtx.subject && (rawCtx.subject.subjectId === 'primary_user' || rawCtx.subject === 'primary_user')) {
       return {
         accepted: false,
         error: {
-          code: 'UNAUTHORIZED_CHANNEL_OR_CAPABILITY',
-          message: 'Operator channel requires explicit operator capability',
-          fields: ['actor.capabilities'],
+          code: 'FORBIDDEN_CONTEXT',
+          message: 'Global primary_user subject is forbidden',
+          field: 'subject.subjectId',
           correlationId,
         },
       };
     }
 
-    // Check subject policy
-    let subject = rawCtx.subject;
-    if (subject) {
-      if (subject.subjectId === 'primary_user' || subject === 'primary_user') {
-        // Global primary_user is rejected or quarantined
-        return {
-          accepted: false,
-          error: {
-            code: 'FORBIDDEN_CONTEXT',
-            message: 'Global primary_user subject is forbidden',
-            field: 'subject.subjectId',
-            correlationId,
-          },
-        };
-      }
-    }
-
     const constructed: RequestContext = {
       companionId,
       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,
-        capabilities,
-        authenticated: Boolean(actor.authenticated),
+        ...actor,
       },
       conversation: {
-        channel,
-        audienceId,
-        isLive: rawCtx.conversation?.isLive,
         correlationId,
+        channel: rawCtx.conversation?.channel || input.channel || 'direct',
+        isLive: rawCtx.conversation?.isLive,
+        ...rawCtx.conversation,
       },
-      subject,
+      source: input.source || rawCtx.source || 'local',
+      subject: rawCtx.subject,
     };
 
     const validated = validateRequestContext(constructed);
@@ -203,9 +113,9 @@ export function mapRequestContext(
     };
   }
 
-  // 2. Legacy compatibility envelope mapping
+  // 2. Synthesize clean RequestContext from request envelope
   const companionId = input.companionId || input.id;
-  const correlationId = input.correlationId || input.conversation?.correlationId;
+  const correlationId = input.correlationId || input.conversation?.correlationId || (input.generateCorrelationId ? `corr-${Date.now()}` : undefined);
 
   if (!companionId) {
     return {
@@ -222,49 +132,16 @@ export function mapRequestContext(
     diagnostics.push('companion_default_mapped_for_bootstrap');
   }
 
-  // Map legacy role to authorizationRole
-  const legacyRole = input.role?.toString().toUpperCase();
-  let authRole: AuthorizationRole = 'viewer';
-  if (legacyRole === 'OWNER') {
-    authRole = 'administrator';
-    diagnostics.push('legacy_role_mapped_to_authorization');
-  } else if (legacyRole === 'OPERATOR') {
-    authRole = 'operator';
-    diagnostics.push('legacy_role_mapped_to_authorization');
-  } else if (legacyRole === 'VIEWER') {
-    authRole = 'viewer';
-    diagnostics.push('legacy_role_mapped_to_authorization');
-  } else if (input.role) {
-    return {
-      accepted: false,
-      error: {
-        code: 'INVALID_CONTEXT',
-        field: 'role',
-        correlationId,
-      },
-    };
-  }
-
-  // Check endpoint policy vs legacy request
-  if (endpointPolicy === 'private' || endpointPolicy === 'operator' || endpointPolicy === 'direct') {
-    // Missing explicit channel, audience, or capability on private/operator endpoint is an error
-    const fields: string[] = [];
-    if (!input.channel) fields.push('conversation.channel');
-    if (!input.audienceId) fields.push('conversation.audienceId');
-    if (!input.capabilities && !input.actor?.capabilities) fields.push('actor.capabilities');
-    if (!correlationId) fields.push('conversation.correlationId');
-
+  if (!correlationId) {
     return {
       accepted: false,
       error: {
         code: 'MISSING_CONTEXT',
-        fields: fields.length > 0 ? fields : ['conversation.audienceId', 'actor.capabilities'],
-        correlationId,
+        fields: ['conversation.correlationId'],
       },
     };
   }
 
-  // Ambiguity check: if legacy input specifies role without correlationId or endpoint context for stateful op
   if (input.subject === 'primary_user' || input.subjectId === 'primary_user') {
     return {
       accepted: false,
@@ -277,55 +154,43 @@ export function mapRequestContext(
     };
   }
 
-  // Missing correlationId for stateful requests
-  const finalCorrelationId = correlationId || (input.generateCorrelationId ? `corr-${Date.now()}` : undefined);
-  if (!finalCorrelationId) {
-    return {
-      accepted: false,
-      error: {
-        code: 'MISSING_CONTEXT',
-        fields: ['conversation.correlationId'],
-      },
-    };
-  }
-
-  // Build anonymous public context
-  const actorId = input.actorId || input.actor?.actorId || 'anonymous-session-a';
-  const sessionId = input.sessionId || input.actor?.sessionId || 'session-a';
+  const actorId = input.actorId || input.actor?.actorId || 'local-user';
+  const sessionId = input.sessionId || input.actor?.sessionId || `session-${Date.now()}`;
   if (!input.actorId && !input.actor?.actorId) {
     diagnostics.push('anonymous_session_generated');
   }
 
-  const channel: Channel = 'public';
-  const audienceId = defaultPublicAudience;
-  diagnostics.push('audience_defaulted_by_public_policy');
-
-  const capabilities = authRole === 'administrator'
-    ? ['chat:public', 'admin:access']
-    : authRole === 'operator'
-    ? ['chat:public', 'operator:access']
-    : ['chat:public'];
+  const capabilities = Array.isArray(input.capabilities)
+    ? input.capabilities
+    : Array.isArray(input.actor?.capabilities)
+    ? input.actor.capabilities
+    : ['chat', 'system'];
 
   const mappedContext: RequestContext = {
     companionId,
     actor: {
       actorId,
       sessionId,
-      authorizationRole: authRole,
       capabilities,
-      authenticated: Boolean(input.authenticated),
+      authenticated: input.authenticated !== undefined ? Boolean(input.authenticated) : true,
+      authorizationRole: input.role ? (input.role.toLowerCase() === 'viewer' ? 'viewer' : 'administrator') : undefined,
     },
     conversation: {
-      channel,
-      audienceId,
-      correlationId: finalCorrelationId,
+      channel: input.channel || input.conversation?.channel || 'direct',
+      correlationId,
     },
-    subject: undefined, // Anonymous public chat has no subject
+    source: input.source || 'local',
+    subject: input.subject,
   };
 
+  const validated = validateRequestContext(mappedContext);
+  if (!validated.accepted) {
+    return validated;
+  }
+
   return {
     accepted: true,
-    context: mappedContext,
+    context: validated.context,
     diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
   };
 }

package/src/index.test.ts

@@ -31,7 +31,10 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
     expect(res.status).toBe(200);
     expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith(
       'Hello neutral world',
-      'OWNER',
+      expect.objectContaining({
+        companionId: 'companion-a',
+        conversation: expect.objectContaining({ channel: 'direct' }),
+      }),
       []
     );
   });
@@ -51,7 +54,6 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
           },
           conversation: {
             channel: 'public',
-            audienceId: 'audience-public',
             correlationId: 'corr-route-1',
           },
         },
@@ -62,39 +64,14 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
     expect(res.status).toBe(200);
     expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith(
       'Hello structured context',
-      'VIEWER',
+      expect.objectContaining({
+        companionId: 'companion-a',
+        conversation: expect.objectContaining({ channel: 'public' }),
+      }),
       []
     );
   });
 
-  test('rejects MASTER_PRIVATE in public request with 400 and structured error', async () => {
-    const res = await request(app)
-      .post('/chat')
-      .send({
-        companionId: 'companion-a',
-        context: {
-          actor: {
-            actorId: 'actor-a',
-            sessionId: 'session-a',
-            authorizationRole: 'viewer',
-            capabilities: ['chat:public'],
-            authenticated: false,
-          },
-          conversation: {
-            channel: 'public',
-            audienceId: 'MASTER_PRIVATE',
-            correlationId: 'corr-err-1',
-          },
-        },
-        message: 'Forbidden audience test',
-      });
-
-    expect(res.status).toBe(400);
-    expect(res.body.accepted).toBe(false);
-    expect(res.body.error.code).toBe('LEGACY_PERSONAL_AUDIENCE');
-    expect(fakeRuntime.handleUserMessage).not.toHaveBeenCalled();
-  });
-
   test('rejects global primary_user subject with 400 and structured error', async () => {
     const res = await request(app)
       .post('/chat')
@@ -110,7 +87,6 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
           },
           conversation: {
             channel: 'public',
-            audienceId: 'audience-public',
             correlationId: 'corr-err-2',
           },
           subject: {
@@ -126,4 +102,57 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
     expect(res.body.error.code).toBe('FORBIDDEN_CONTEXT');
     expect(fakeRuntime.handleUserMessage).not.toHaveBeenCalled();
   });
+
+  test('streams response chunks via POST /chat/stream', async () => {
+    fakeRuntime.mouth = {
+      stream: async function* () {
+        yield { utteranceId: 'utt-1', index: 1, deltaText: 'Hello', isComplete: false, medium: 'web' };
+        yield { utteranceId: 'utt-1', index: 2, deltaText: ' world', isComplete: false, medium: 'web' };
+        yield { utteranceId: 'utt-1', index: 3, deltaText: '', isComplete: true, medium: 'web' };
+      },
+    };
+
+    const res = await request(app)
+      .post('/chat/stream')
+      .send({
+        id: 'companion-a',
+        message: 'Stream me',
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toContain('text/event-stream');
+    expect(res.text).toContain('event: staged');
+    expect(res.text).toContain('event: chunk');
+    expect(res.text).toContain('event: done');
+  });
+
+  test('handles barge-in interruption via POST /chat/interrupt', async () => {
+    fakeRuntime.interruptMouth = jest.fn();
+
+    const res = await request(app)
+      .post('/chat/interrupt')
+      .send({
+        companionId: 'companion-a',
+        reason: 'user_stop',
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.interrupted).toBe(true);
+    expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_stop');
+  });
+
+  test('handles mouth interruption via POST /mouth/interrupt', async () => {
+    fakeRuntime.interruptMouth = jest.fn();
+
+    const res = await request(app)
+      .post('/mouth/interrupt')
+      .send({
+        companionId: 'companion-a',
+        reason: 'user_barge_in',
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.interrupted).toBe(true);
+    expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_barge_in');
+  });
 });

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', () => {
@@ -78,7 +79,7 @@ describe('Siduri Runtime Orchestration', () => {
     expect(noKnowledgeContext).toBe(true);
     expect(proposedClaims.length).toBe(1);
     expect(proposedClaims[0].subject).toBe("Test");
-    expect(proposedClaims[0].scope).toBe("OWNER");
+    expect(proposedClaims[0].scope).toBe("user");
     expect(response.metadata.memory_proposals[0].proposal_id).toBe("claim-1");
   });
 
@@ -94,7 +95,7 @@ describe('Siduri Runtime Orchestration', () => {
         riskLevel: 'LOW',
         requiredCapabilities: ['chat:public'],
       },
-      execute: async (params) => {
+      execute: async (params: any) => {
         toolExecuted = true;
         return { hits: [`Result for ${params.query}`] };
       },
@@ -146,7 +147,6 @@ describe('Siduri Runtime Orchestration', () => {
       },
       conversation: {
         channel: 'direct',
-        audienceId: 'audience-direct',
         correlationId: 'corr-alice-123',
       },
     };
@@ -233,7 +233,6 @@ describe('Siduri Runtime Orchestration', () => {
       },
       conversation: {
         channel: 'public',
-        audienceId: 'audience-public',
         correlationId: 'corr-bob-999',
       },
     };
@@ -281,4 +280,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: any) => {
+            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/src/t5-experience.test.ts

@@ -161,7 +161,6 @@ describe('T5 Experience Event and Output Adapters Suite', () => {
       responseId: 'resp-1',
       correlationId: 'corr-1',
       channel: 'public' as const,
-      audienceId: 'audience-public',
       approval: 'STAGED' as any, // Not approved!
       kind: 'voice' as const,
       lifecycle: 'STARTED' as const,

package/src/t6-security.test.ts

@@ -168,7 +168,6 @@ describe('T6 Security & Operations Threat Model Suite', () => {
       responseId: 'resp-1',
       correlationId: 'corr-1',
       channel: 'public',
-      audienceId: 'audience-public',
       approval: 'APPROVED',
       kind: 'voice',
       lifecycle: 'STARTED',

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;