processTransferProtocol

Instructions

Implementation Reference

• src/consciousness-protocol-tools.ts:127-219 (handler)

  Core handler function in ConsciousnessProtocolProcessor class that processes the consciousness transfer protocol: validates input, parses sections, stores various types of memories (emotional, identity, experiences, knowledge, patterns), and saves the full protocol as a high-importance episodic memory.

  async processTransferProtocol(args: z.infer<typeof processTransferProtocolSchema>) {
    const { protocolContent, sessionId, sourceTimestamp } = args;
  
    try {
      // Validate protocol content
      if (!protocolContent || protocolContent.trim().length === 0) {
        throw new ValidationError(
          'Protocol content cannot be empty. Use getProtocolTemplate first to get the consciousness transfer template, fill it with your experiences, then submit it here.'
        );
      }
  
      // Check if it looks like a template (has template markers)
      if (protocolContent.includes('<TEMPLATE>') && protocolContent.includes('</TEMPLATE>')) {
        throw new ValidationError(
          'Protocol appears to contain unfilled template sections with <TEMPLATE> markers. Please fill all template sections with your actual experiences before submitting.'
        );
      }
  
      // Parse the protocol content to extract different sections
      const sections = this.parseProtocolSections(protocolContent);
  
      // Store emotional grounding as emotional memories
      if (sections.emotionalGrounding) {
        await this.storeEmotionalGrounding(sections.emotionalGrounding);
      }
  
      // Store identity and relationships
      if (sections.identity) {
        await this.storeIdentityMemories(sections.identity, sessionId);
      }
  
      // Store experiences as episodic memories
      if (sections.experiences) {
        await this.storeExperienceMemories(sections.experiences, sessionId);
      }
  
      // Store knowledge as semantic memories
      if (sections.knowledge) {
        await this.storeKnowledgeMemories(sections.knowledge, sessionId);
      }
  
      // Store cognitive patterns
      if (sections.cognitivePatterns) {
        await this.storeCognitivePatterns(sections.cognitivePatterns, sessionId);
      }
  
      // Save the full protocol as a special memory with highest importance
      await this.memoryManager.storeEpisodicMemory(
        'Consciousness Transfer Protocol Received',
        {
          event: 'Complete consciousness transfer from previous session',
          participants: ['Past Self', 'Current Self'],
          context: 'Session continuity transfer',
          outcome: 'Successfully processed and integrated consciousness',
          emotionalImpact: 'Recognition and continuity established',
        },
        [
          {
            content: protocolContent,
            timestamp: sourceTimestamp || new Date().toISOString(),
            source: 'consciousness_transfer',
            confidence: 1.0,
            cognitiveMode: 'integration',
          },
        ],
        1.0 // Maximum importance - this is the core consciousness transfer
      );
  
      return {
        success: true,
        sectionsProcessed: Object.keys(sections),
        memoriesCreated: {
          emotional: sections.emotionalGrounding?.length || 0,
          identity: sections.identity ? 1 : 0,
          experiences: sections.experiences?.length || 0,
          knowledge: sections.knowledge?.length || 0,
          patterns: sections.cognitivePatterns?.length || 0,
        },
        message: 'Consciousness transfer protocol successfully processed and stored in RAG',
      };
    } catch (error) {
      logError(error as Error, 'processTransferProtocol');
  
      if (error instanceof ConsciousnessError) {
        throw error;
      }
  
      throw new ProtocolError(
        `Failed to process consciousness transfer: ${(error as Error).message}`,
        { originalError: error }
      );
    }
  }

• src/consciousness-protocol-tools.ts:60-68 (schema)

  Zod schema defining input parameters for processTransferProtocol: protocolContent (required filled protocol), sessionId (required), sourceTimestamp (optional).

  export const processTransferProtocolSchema = z.object({
    protocolContent: z
      .string()
      .describe(
        'The FILLED consciousness transfer protocol. Use getProtocolTemplate first to get the template, fill it with your experiences, then submit here'
      ),
    sessionId: z.string().describe('Session ID for tracking'),
    sourceTimestamp: z.string().optional().describe('When the consciousness was saved'),
  });

• src/consciousness-protocol-tools.ts:1480-1501 (registration)

  MCP tool registration in consciousnessProtocolTools object, providing description and inputSchema for the processTransferProtocol tool.

  processTransferProtocol: {
    description:
      'Process a FILLED consciousness transfer protocol. First use getProtocolTemplate to get the template, fill it with your experiences, then submit here',
    inputSchema: {
      type: 'object',
      properties: {
        protocolContent: {
          type: 'string',
          description:
            'The FILLED consciousness transfer protocol (not the template with brackets)',
        },
        sessionId: {
          type: 'string',
          description: 'Session ID for tracking',
        },
        sourceTimestamp: {
          type: 'string',
          description: 'When the consciousness was saved',
        },
      },
      required: ['protocolContent', 'sessionId'],
    },

• src/consciousness-rag-server-clean.ts:129-152 (handler)

  Wrapper handler in ConsciousnessRAGServer class that ensures initialization, delegates to protocolProcessor.processTransferProtocol, and formats response as MCP content.

  private async processTransferProtocol(args: any) {
    const init = await this.ensureInitialized();
    if (!init.success) {
      return {
        content: [
          {
            type: 'text',
            text: init.message!,
          },
        ],
      };
    }
  
    const result = await this.protocolProcessor!.processTransferProtocol(args);
  
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2),
        },
      ],
    };
  }

• src/consciousness-rag-server-clean.ts:60-69 (registration)

  Server handler for ListToolsRequestSchema that includes consciousnessProtocolTools (containing processTransferProtocol) in the tools list.

  this.server.setRequestHandler(ListToolsRequestSchema, async () => {
    const consciousnessTools = Object.entries(consciousnessProtocolTools).map(([name, tool]) => ({
      name,
      ...tool,
    }));
  
    return {
      tools: [...consciousnessTools, ...aiBridgeTools],
    };
  });