@siduri-x/api 1.0.2 → 1.0.4

package/src/context-mapper.test.ts

@@ -1,116 +1,56 @@
 import { mapRequestContext } from './context-mapper';
 
-describe('API Request Context Mapper (P2 & T1-01 to T1-10)', () => {
-  // T1-01: Anonymous public chat, no audience
-  test('T1-01: Anonymous public chat with no audience resolves to configured public audience and no subject', () => {
+describe('API Request Context Mapper (Single-Owner, Single-Machine)', () => {
+  test('Local chat request maps to valid RequestContext with local user defaults', () => {
     const input = {
       companionId: 'companion-a',
-      context: {
-        actor: {
-          actorId: 'anonymous-session-a',
-          sessionId: 'session-a',
-          authorizationRole: 'viewer',
-          capabilities: ['chat:public'],
-          authenticated: false,
-        },
-        conversation: {
-          channel: 'public',
-          correlationId: 'corr-public-a',
-        },
-      },
-      message: 'Hello.',
-      history: [],
+      message: 'Hello world',
+      correlationId: 'corr-local-1',
     };
 
-    const result = mapRequestContext(input, {
-      endpointPolicy: 'public',
-      defaultPublicAudience: 'audience-public',
-    });
+    const result = mapRequestContext(input);
 
     expect(result.accepted).toBe(true);
     expect(result.context?.companionId).toBe('companion-a');
-    expect(result.context?.conversation.channel).toBe('public');
-    expect(result.context?.conversation.audienceId).toBe('audience-public');
-    expect(result.context?.subject).toBeUndefined();
-    expect(result.diagnostics).toContain('audience_defaulted_by_public_policy');
-  });
-
-  // T1-02: OWNER public chat
-  test('T1-02: OWNER public chat maps authorization metadata only with no relationship or private routing', () => {
-    const input = {
-      id: 'companion-a',
-      role: 'OWNER',
-      correlationId: 'corr-owner-public',
-      message: 'Public broadcast message',
-    };
-
-    const result = mapRequestContext(input, { endpointPolicy: 'public' });
-    expect(result.accepted).toBe(true);
-    expect(result.context?.actor.authorizationRole).toBe('administrator');
-    expect(result.context?.conversation.channel).toBe('public');
-    expect(result.context?.conversation.audienceId).toBe('audience-public');
+    expect(result.context?.actor.actorId).toBe('local-user');
+    expect(result.context?.actor.authenticated).toBe(true);
+    expect(result.context?.conversation.correlationId).toBe('corr-local-1');
+    expect(result.context?.source).toBe('local');
     expect(result.context?.subject).toBeUndefined();
-    expect(result.diagnostics).toContain('legacy_role_mapped_to_authorization');
   });
 
-  // T1-03: Private chat without capability
-  test('T1-03: Private chat without capability is rejected before organ invocation', () => {
+  test('Accepts structured context envelope', () => {
     const input = {
       companionId: 'companion-a',
       context: {
         actor: {
-          actorId: 'actor-a',
-          sessionId: 'session-a',
-          authorizationRole: 'viewer',
-          capabilities: ['chat:public'], // Missing 'chat:private'
+          actorId: 'user-main',
+          sessionId: 'session-main',
           authenticated: true,
+          capabilities: ['chat', 'system'],
         },
         conversation: {
-          channel: 'private',
-          audienceId: 'audience-private-a',
-          correlationId: 'corr-private-a',
+          correlationId: 'corr-structured-1',
         },
       },
-      message: 'Show private data',
-    };
-
-    const result = mapRequestContext(input, { endpointPolicy: 'private' });
-    expect(result.accepted).toBe(false);
-    expect(result.error?.code).toBe('UNAUTHORIZED_CHANNEL_OR_CAPABILITY');
-    expect(result.error?.fields).toContain('actor.capabilities');
-  });
-
-  // T1-04: Operator request without operator context
-  test('T1-04: Operator request without operator context is rejected with diagnostic', () => {
-    const input = {
-      id: 'companion-a',
-      role: 'OPERATOR',
-      correlationId: 'corr-op-missing',
+      message: 'Hello structured context',
     };
 
-    const result = mapRequestContext(input, { endpointPolicy: 'operator' });
-    expect(result.accepted).toBe(false);
-    expect(result.error?.code).toBe('MISSING_CONTEXT');
-    expect(result.error?.fields).toEqual(
-      expect.arrayContaining(['conversation.channel', 'conversation.audienceId', 'actor.capabilities'])
-    );
+    const result = mapRequestContext(input);
+    expect(result.accepted).toBe(true);
+    expect(result.context?.actor.actorId).toBe('user-main');
+    expect(result.context?.conversation.correlationId).toBe('corr-structured-1');
   });
 
-  // T1-05: Global primary_user input
-  test('T1-05: Global primary_user input is rejected/quarantined at mapper', () => {
+  test('Rejects global primary_user subject', () => {
     const input = {
       companionId: 'companion-a',
       context: {
         actor: {
-          actorId: 'actor-a',
+          actorId: 'user-a',
           sessionId: 'session-a',
-          authorizationRole: 'viewer',
-          capabilities: ['chat:public'],
-          authenticated: true,
         },
         conversation: {
-          channel: 'public',
-          audienceId: 'audience-public',
           correlationId: 'corr-primary-user',
         },
         subject: {
@@ -126,47 +66,15 @@ describe('API Request Context Mapper (P2 & T1-01 to T1-10)', () => {
     expect(result.error?.field).toBe('subject.subjectId');
   });
 
-  // T1-06: MASTER_PRIVATE in public mode
-  test('T1-06: MASTER_PRIVATE in public mode is rejected with no fallback', () => {
-    const input = {
-      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-master-private',
-        },
-      },
-    };
-
-    const result = mapRequestContext(input, { endpointPolicy: 'public' });
-    expect(result.accepted).toBe(false);
-    expect(result.error?.code).toBe('LEGACY_PERSONAL_AUDIENCE');
-    expect(result.error?.field).toBe('audienceId');
-  });
-
-  // T1-07: Missing actor on explicit teaching
-  test('T1-07: Missing actor on explicit teaching produces no durable profile and pending/anonymous context only', () => {
+  test('Rejects missing actor on structured context', () => {
     const input = {
       companionId: 'companion-a',
       context: {
         actor: {
           actorId: '',
           sessionId: 'session-a',
-          authorizationRole: 'viewer',
-          capabilities: ['chat:public'],
-          authenticated: false,
         },
         conversation: {
-          channel: 'public',
-          audienceId: 'audience-public',
           correlationId: 'corr-teach-no-actor',
         },
       },
@@ -178,18 +86,13 @@ describe('API Request Context Mapper (P2 & T1-01 to T1-10)', () => {
     expect(result.error?.fields).toContain('actor.actorId');
   });
 
-  // T1-08: Two companion IDs, same actor remain isolated
-  test('T1-08: Two companion IDs with same actor remain isolated under context mapper', () => {
+  test('Two companion IDs with same actor remain isolated under context mapper', () => {
     const actor = {
-      actorId: 'actor-a',
+      actorId: 'user-a',
       sessionId: 'session-a',
-      authorizationRole: 'viewer' as const,
-      capabilities: ['chat:public'],
       authenticated: true,
     };
     const conv = {
-      channel: 'public' as const,
-      audienceId: 'audience-public',
       correlationId: 'corr-iso-1',
     };
 
@@ -205,21 +108,27 @@ describe('API Request Context Mapper (P2 & T1-01 to T1-10)', () => {
     expect(resB.context?.companionId).toBe('companion-b');
   });
 
-  // T1-09: Missing correlation ID
-  test('T1-09: Missing correlation ID is rejected before stateful operation', () => {
+  test('Rejects missing companionId', () => {
+    const input = {
+      message: 'No companion id',
+      correlationId: 'corr-no-comp',
+    };
+
+    const result = mapRequestContext(input);
+    expect(result.accepted).toBe(false);
+    expect(result.error?.code).toBe('MISSING_CONTEXT');
+    expect(result.error?.fields).toContain('companionId');
+  });
+
+  test('Rejects missing correlation ID when generateCorrelationId is not set', () => {
     const input = {
       companionId: 'companion-a',
       context: {
         actor: {
-          actorId: 'actor-a',
+          actorId: 'user-a',
           sessionId: 'session-a',
-          authorizationRole: 'viewer',
-          capabilities: ['chat:public'],
-          authenticated: true,
         },
         conversation: {
-          channel: 'public',
-          audienceId: 'audience-public',
           correlationId: '',
         },
       },
@@ -231,28 +140,14 @@ describe('API Request Context Mapper (P2 & T1-01 to T1-10)', () => {
     expect(result.error?.fields).toContain('conversation.correlationId');
   });
 
-  // T1-10: Ambiguous legacy request
-  test('T1-10: Ambiguous legacy request emits structured diagnostic and rejects ambiguous mapping', () => {
+  test('Generates correlationId when generateCorrelationId option is true', () => {
     const input = {
       companionId: 'companion-a',
-      role: 'VIEWER',
-      context: {
-        actor: {
-          actorId: 'actor-a',
-          sessionId: 'session-a',
-          authorizationRole: 'viewer',
-          capabilities: ['chat:public'],
-          authenticated: true,
-        },
-        // Role supplied at top level without channel or audience
-      },
+      generateCorrelationId: true,
     };
 
     const result = mapRequestContext(input);
-    expect(result.accepted).toBe(false);
-    expect(result.error?.code).toBe('AMBIGUOUS_CONTEXT');
-    expect(result.error?.conflicts).toEqual(
-      expect.arrayContaining(['role_does_not_select_audience', 'role_does_not_select_subject'])
-    );
+    expect(result.accepted).toBe(true);
+    expect(result.context?.conversation.correlationId).toMatch(/^corr-/);
   });
 });

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: {